diff --git a/compiler/rustc_ast_pretty/src/helpers.rs b/compiler/rustc_ast_pretty/src/helpers.rs deleted file mode 100644 index 34641ea2f5ae0..0000000000000 --- a/compiler/rustc_ast_pretty/src/helpers.rs +++ /dev/null @@ -1,49 +0,0 @@ -use std::borrow::Cow; - -use crate::pp::Printer; - -impl Printer { - pub fn word_space>>(&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>>(&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>) { - self.word("/*"); - self.space(); - self.word(text); - self.space(); - self.word("*/") - } -} diff --git a/compiler/rustc_ast_pretty/src/lib.rs b/compiler/rustc_ast_pretty/src/lib.rs index a7d9f89fb3df5..bfc1d387b7009 100644 --- a/compiler/rustc_ast_pretty/src/lib.rs +++ b/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; diff --git a/compiler/rustc_ast_pretty/src/pp.rs b/compiler/rustc_ast_pretty/src/pp.rs index 4108671a3629e..c7a38d981b893 100644 --- a/compiler/rustc_ast_pretty/src/pp.rs +++ b/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 @@ impl Printer { 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>) { + 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>>(&mut self, wrd: S) { + let string = wrd.into(); + self.scan_string(string) + } + + pub fn word_space>>(&mut self, w: W) { + self.word(w); + self.space(); + } + + pub fn nbsp(&mut self) { + self.word(" ") + } + + pub fn word_nbsp>>(&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() + }); + } } diff --git a/compiler/rustc_ast_pretty/src/pp/convenience.rs b/compiler/rustc_ast_pretty/src/pp/convenience.rs deleted file mode 100644 index 9b902b38122c8..0000000000000 --- a/compiler/rustc_ast_pretty/src/pp/convenience.rs +++ /dev/null @@ -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>>(&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) - } -} diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs index 6410d0c0cf702..84c83be8b4a5d 100644 --- a/compiler/rustc_attr_parsing/src/attributes/cfg.rs +++ b/compiler/rustc_attr_parsing/src/attributes/cfg.rs @@ -19,6 +19,7 @@ use rustc_session::parse::{ParseSess, feature_err}; 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, diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs index 4ff224006ca89..918fd0a4582b7 100644 --- a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs +++ b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs @@ -12,6 +12,7 @@ use rustc_session::Session; 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, diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs index 73b2727fdab0a..53d02d09bb514 100644 --- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs +++ b/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 @@ pub(crate) struct ExportNameParser; impl SingleAttributeParser for ExportNameParser { const PATH: &[rustc_span::Symbol] = &[sym::export_name]; const ON_DUPLICATE: OnDuplicate = 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 AttributeParser 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 @@ pub(crate) struct NoMangleParser; impl NoArgsAttributeParser for NoMangleParser { const PATH: &[Symbol] = &[sym::no_mangle]; const ON_DUPLICATE: OnDuplicate = 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 @@ pub(crate) struct ForceTargetFeatureParser; impl CombineAttributeParser for ForceTargetFeatureParser { type Item = (Symbol, Span); const PATH: &[Symbol] = &[sym::force_target_feature]; + const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: None }; const CONVERT: ConvertFn = |items, span| AttributeKind::TargetFeature { features: items, attr_span: span, diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs index 8aa7759daa043..b6ba7f9e21d49 100644 --- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs +++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs @@ -5,11 +5,13 @@ use rustc_hir::attrs::*; 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 @@ pub(crate) struct LinkSectionParser; impl SingleAttributeParser for LinkSectionParser { const PATH: &[Symbol] = &[sym::link_section]; const ON_DUPLICATE: OnDuplicate = 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 @@ pub(crate) struct FfiConstParser; impl NoArgsAttributeParser for FfiConstParser { const PATH: &[Symbol] = &[sym::ffi_const]; const ON_DUPLICATE: OnDuplicate = 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 @@ pub(crate) struct FfiPureParser; impl NoArgsAttributeParser for FfiPureParser { const PATH: &[Symbol] = &[sym::ffi_pure]; const ON_DUPLICATE: OnDuplicate = 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; } diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs index d7f64ff2319a9..ad5a541d3a25d 100644 --- a/compiler/rustc_attr_parsing/src/attributes/mod.rs +++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs @@ -18,6 +18,7 @@ use std::marker::PhantomData; 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: Default + 'static { /// If an attribute has this symbol, the `accept` function will be called on it. const ATTRIBUTES: AcceptMapping; 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: 'static { /// Configures what to do when when the same attribute is /// applied more than once on the same syntax node. const ON_DUPLICATE: OnDuplicate; + const SAFETY: AttributeSafety = AttributeSafety::Normal; const ALLOWED_TARGETS: AllowedTargets; @@ -165,6 +168,7 @@ impl, S: Stage> AttributeParser for Single }, )]; const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS; + const SAFETY: AttributeSafety = T::SAFETY; fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option { Some(self.1?.0) @@ -217,6 +221,18 @@ impl OnDuplicate { } } +#[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 }, +} + /// 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: 'static { const PATH: &[Symbol]; const ON_DUPLICATE: OnDuplicate; 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 @@ impl, S: Stage> Default for WithoutArgs { impl, S: Stage> SingleAttributeParser for WithoutArgs { const PATH: &[Symbol] = T::PATH; const ON_DUPLICATE: OnDuplicate = 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: '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; + const SAFETY: AttributeSafety = AttributeSafety::Normal; const ALLOWED_TARGETS: AllowedTargets; @@ -312,6 +331,7 @@ impl, S: Stage> AttributeParser for Combine) -> Option { if let Some(first_span) = self.first_span { diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs index 3f722bef5bf35..647c816247bf9 100644 --- a/compiler/rustc_attr_parsing/src/context.rs +++ b/compiler/rustc_attr_parsing/src/context.rs @@ -59,7 +59,7 @@ use crate::attributes::stability::*; 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 { pub(super) template: AttributeTemplate, pub(super) accept_fn: AcceptFn, pub(super) allowed_targets: AllowedTargets, + pub(super) safety: AttributeSafety, pub(super) finalizer: FinalizeFn, } @@ -126,6 +127,7 @@ macro_rules! attribute_parsers { 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(); diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs index 68016d81c954c..85e714a1a917c 100644 --- a/compiler/rustc_attr_parsing/src/interface.rs +++ b/compiler/rustc_attr_parsing/src/interface.rs @@ -12,6 +12,7 @@ use rustc_session::Session; 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 @@ impl<'sess> AttributeParser<'sess, Early> { parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser) -> Option, template: &AttributeTemplate, allow_expr_metavar: AllowExprMetavar, + expected_safety: AttributeSafety, ) -> Option { let ast::AttrKind::Normal(normal_attr) = &attr.kind else { panic!("parse_single called on a doc attr") @@ -157,6 +159,7 @@ impl<'sess> AttributeParser<'sess, Early> { attr.style, path, Some(normal_attr.item.unsafety), + expected_safety, ParsedDescription::Attribute, target_span, target_node_id, @@ -178,6 +181,7 @@ impl<'sess> AttributeParser<'sess, Early> { attr_style: AttrStyle, attr_path: AttrPath, attr_safety: Option, + expected_safety: AttributeSafety, parsed_description: ParsedDescription, target_span: Span, target_node_id: NodeId, @@ -199,7 +203,13 @@ impl<'sess> AttributeParser<'sess, Early> { 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 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> { } }; - 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::>(); 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 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> { 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 { diff --git a/compiler/rustc_attr_parsing/src/lib.rs b/compiler/rustc_attr_parsing/src/lib.rs index 93eb5a0c3ab73..1b08ed3c49b78 100644 --- a/compiler/rustc_attr_parsing/src/lib.rs +++ b/compiler/rustc_attr_parsing/src/lib.rs @@ -106,6 +106,7 @@ mod session_diagnostics; 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, }; diff --git a/compiler/rustc_attr_parsing/src/safety.rs b/compiler/rustc_attr_parsing/src/safety.rs index 262c9c7723eeb..26212ee5f4ca2 100644 --- a/compiler/rustc_attr_parsing/src/safety.rs +++ b/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 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> { 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 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> { // - 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 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> { // - 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", diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs index ffe5e15c48ec1..2bbaf3e5c8174 100644 --- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs +++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs @@ -4040,23 +4040,74 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> { 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, diff --git a/compiler/rustc_builtin_macros/src/cfg.rs b/compiler/rustc_builtin_macros/src/cfg.rs index c4a458089f2d2..2872cff0fdc7a 100644 --- a/compiler/rustc_builtin_macros/src/cfg.rs +++ b/compiler/rustc_builtin_macros/src/cfg.rs @@ -6,7 +6,8 @@ use rustc_ast::tokenstream::TokenStream; 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 IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { } 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") + } + } + 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`") } - _ => bug!("the va_arg intrinsic does not work with non-scalar types"), } } diff --git a/compiler/rustc_data_structures/src/aligned.rs b/compiler/rustc_data_structures/src/aligned.rs index d653847f1c60d..290d30871fe64 100644 --- a/compiler/rustc_data_structures/src/aligned.rs +++ b/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. /// diff --git a/compiler/rustc_data_structures/src/tagged_ptr.rs b/compiler/rustc_data_structures/src/tagged_ptr.rs index 32f8138110895..67c8a92dd89bb 100644 --- a/compiler/rustc_data_structures/src/tagged_ptr.rs +++ b/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() -> u32 { let alignment = crate::aligned::align_of::(); - #[cfg(bootstrap)] - let alignment = alignment.as_nonzero(); - #[cfg(not(bootstrap))] let alignment = alignment.as_nonzero_usize(); alignment.trailing_zeros() } diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs index e85e130a9e6b3..f7ab7957b4e50 100644 --- a/compiler/rustc_expand/src/config.rs +++ b/compiler/rustc_expand/src/config.rs @@ -12,8 +12,8 @@ use rustc_ast::{ }; 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 @@ impl<'a> StripUnconfigured<'a> { parse_cfg, &CFG_TEMPLATE, AllowExprMetavar::Yes, + AttributeSafety::Normal, ) else { // Cfg attribute was not parsable, give up return EvalConfigResult::True; diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs index 5901f318ff3a9..804d3c02b413d 100644 --- a/compiler/rustc_expand/src/expand.rs +++ b/compiler/rustc_expand/src/expand.rs @@ -15,8 +15,8 @@ use rustc_ast::{ 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 @@ impl<'a, 'b> InvocationCollector<'a, 'b> { parse_cfg, &CFG_TEMPLATE, AllowExprMetavar::Yes, + AttributeSafety::Normal, ) else { // Cfg attribute was not parsable, give up return EvalConfigResult::True; diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index 1c1bca0cbc3cf..144c9f6d0c4dc 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -5,7 +5,6 @@ use std::sync::LazyLock; 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 }, -} - #[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 static BUILTIN_ATTRIBUTES: &[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 static BUILTIN_ATTRIBUTES: &[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!( - doc, - ), + 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), // 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 static BUILTIN_ATTRIBUTES: &[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 static BUILTIN_ATTRIBUTES: &[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 static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ BuiltinAttribute { name: sym::rustc_diagnostic_item, - safety: AttributeSafety::Normal, gate: Gated { feature: sym::rustc_attrs, message: "use of an internal attribute", @@ -961,99 +748,39 @@ pub static BUILTIN_ATTRIBUTES: &[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 { diff --git a/compiler/rustc_feature/src/lib.rs b/compiler/rustc_feature/src/lib.rs index 34ac6b3f9a7c8..ce3ce6fcccee4 100644 --- a/compiler/rustc_feature/src/lib.rs +++ b/compiler/rustc_feature/src/lib.rs @@ -129,7 +129,7 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option FnCtxt<'a, '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"); diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs index a2f4c57bd442c..b5d138f183b99 100644 --- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs +++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs @@ -3107,14 +3107,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { { 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); diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs index 1b8c8e3bd2c86..c84b06769e081 100644 --- a/compiler/rustc_index/src/lib.rs +++ b/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; diff --git a/compiler/rustc_lint/src/types/improper_ctypes.rs b/compiler/rustc_lint/src/types/improper_ctypes.rs index 38f2fbb07ed3e..965cd23c762ae 100644 --- a/compiler/rustc_lint/src/types/improper_ctypes.rs +++ b/compiler/rustc_lint/src/types/improper_ctypes.rs @@ -138,6 +138,17 @@ declare_lint_pass!(ImproperCTypesLint => [ 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 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { 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 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { 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 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { // 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 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { } } - 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 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, '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. diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs index 3b1c599e0fa15..2d9be11cb3057 100644 --- a/compiler/rustc_lint_defs/src/builtin.rs +++ b/compiler/rustc_lint_defs/src/builtin.rs @@ -2720,13 +2720,12 @@ declare_lint! { /// /// ### 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}} /// diff --git a/compiler/rustc_middle/src/query/job.rs b/compiler/rustc_middle/src/query/job.rs index 24c4daf9855d2..8c78bf24287e0 100644 --- a/compiler/rustc_middle/src/query/job.rs +++ b/compiler/rustc_middle/src/query/job.rs @@ -36,10 +36,7 @@ impl<'tcx> QueryJob<'tcx> { } 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. diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs index a2bbc1ec75b99..ed5a48b094f24 100644 --- a/compiler/rustc_middle/src/ty/list.rs +++ b/compiler/rustc_middle/src/ty/list.rs @@ -275,9 +275,6 @@ unsafe impl DynSync for RawList {} // `_extern_ty` field (which is never instantiated in practice). Therefore, // aligns of `ListSkeleton` and `RawList` must be the same. unsafe impl Aligned for RawList { - #[cfg(bootstrap)] - const ALIGN: ptr::Alignment = align_of::>(); - #[cfg(not(bootstrap))] const ALIGN: mem::Alignment = align_of::>(); } diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs index cbcf1a182c7e1..ad8c5e838b486 100644 --- a/compiler/rustc_resolve/src/late/diagnostics.rs +++ b/compiler/rustc_resolve/src/late/diagnostics.rs @@ -26,7 +26,7 @@ use rustc_middle::ty; 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 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> { 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), ); diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 9cd66bc1604d1..c2f597b358f53 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -2210,6 +2210,7 @@ symbols! { v1, v8plus, va_arg, + va_arg_safe, va_copy, va_end, va_list, diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs index ac6e345ec1de1..905b005cd48f8 100644 --- a/compiler/rustc_type_ir/src/infer_ctxt.rs +++ b/compiler/rustc_type_ir/src/infer_ctxt.rs @@ -41,7 +41,7 @@ use crate::{self as ty, Interner, TyVid}; 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 { /// When checking whether impls overlap, we check whether any obligations /// are guaranteed to never hold when unifying the impls. This requires us diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs index 8a3326c7d76a7..2966f3ccc1791 100644 --- a/library/alloc/src/str.rs +++ b/library/alloc/src/str.rs @@ -335,13 +335,19 @@ impl str { /// 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 @@ impl str { 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 @@ impl str { /// 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 @@ impl str { 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 { /// /// 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. diff --git a/library/core/src/cell/lazy.rs b/library/core/src/cell/lazy.rs index 9d350166c681b..66436ed7d94fb 100644 --- a/library/core/src/cell/lazy.rs +++ b/library/core/src/cell/lazy.rs @@ -367,7 +367,7 @@ impl fmt::Debug for LazyCell { } } -#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "from_wrapper_impls", since = "1.96.0")] impl From for LazyCell { /// Constructs a `LazyCell` that starts already initialized /// with the provided value. diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs index caf4e9f5917fb..00b735e91a377 100644 --- a/library/core/src/char/methods.rs +++ b/library/core/src/char/methods.rs @@ -1151,13 +1151,14 @@ impl char { /// [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 @@ impl char { /// // 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 @@ impl char { /// `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 @@ impl char { /// [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 @@ impl char { /// ``` /// #![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 @@ impl char { /// 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 @@ impl char { /// ``` /// /// 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 @@ impl char { /// 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 @@ impl char { /// [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 @@ impl char { /// [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 @@ impl char { /// /// ``` /// 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 @@ impl char { /// /// # 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 @@ impl char { /// ``` /// /// 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")] diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs index 62b3d75d7a779..e3a3aed4a7945 100644 --- a/library/core/src/ffi/c_str.rs +++ b/library/core/src/ffi/c_str.rs @@ -716,7 +716,7 @@ impl ops::Index> for CStr { } } -#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_from_api", since = "1.96.0")] impl ops::Index> for CStr { type Output = CStr; diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs index f0f58a0f83430..034e4ad728b8a 100644 --- a/library/core/src/ffi/va_list.rs +++ b/library/core/src/ffi/va_list.rs @@ -266,14 +266,17 @@ impl<'f> const Drop for VaList<'f> { 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 Sealed for *mut T {} @@ -297,24 +300,64 @@ mod sealed { // 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 VaArgSafe for *mut T {} unsafe impl VaArgSafe for *const T {} +// Check that relevant `core::ffi` types implement `VaArgSafe`. +const _: () = { + const fn va_arg_safe_check() {} + + va_arg_safe_check::(); + va_arg_safe_check::(); + va_arg_safe_check::(); + va_arg_safe_check::(); + va_arg_safe_check::(); + va_arg_safe_check::(); + va_arg_safe_check::(); +}; + impl<'f> VaList<'f> { /// Read an argument from the variable argument list, and advance to the next argument. /// diff --git a/library/core/src/mem/alignment.rs b/library/core/src/mem/alignment.rs index a8c4c8ea78ff7..82f693f0a9ccc 100644 --- a/library/core/src/mem/alignment.rs +++ b/library/core/src/mem/alignment.rs @@ -178,7 +178,7 @@ impl Alignment { /// Returns the alignment as a [NonZero]<[usize]>. #[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" )] diff --git a/library/core/src/ops/control_flow.rs b/library/core/src/ops/control_flow.rs index f532e8f116f05..5f8974133a94e 100644 --- a/library/core/src/ops/control_flow.rs +++ b/library/core/src/ops/control_flow.rs @@ -262,8 +262,8 @@ impl ControlFlow { /// 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 { match self { @@ -374,8 +374,8 @@ impl ControlFlow { /// 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 { match self { diff --git a/library/core/src/panic/unwind_safe.rs b/library/core/src/panic/unwind_safe.rs index 20f85b5ca9cd8..f7f485488e0fe 100644 --- a/library/core/src/panic/unwind_safe.rs +++ b/library/core/src/panic/unwind_safe.rs @@ -317,7 +317,7 @@ impl AsyncIterator for AssertUnwindSafe { /// 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 From for AssertUnwindSafe where T: UnwindSafe, diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs index ddeb1ccc72af7..b8202e903285e 100644 --- a/library/core/src/ptr/mod.rs +++ b/library/core/src/ptr/mod.rs @@ -413,7 +413,7 @@ use crate::num::NonZero; 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; diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs index 289dd972f679c..98b70a77fad7b 100644 --- a/library/core/src/ptr/mut_ptr.rs +++ b/library/core/src/ptr/mut_ptr.rs @@ -594,7 +594,7 @@ impl *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 /// diff --git a/library/core/src/range.rs b/library/core/src/range.rs index 1200f8922c819..ade9a35b0ab33 100644 --- a/library/core/src/range.rs +++ b/library/core/src/range.rs @@ -24,13 +24,13 @@ mod iter; 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 @@ use crate::ops::{IntoBounds, OneSidedRange, OneSidedRangeBound, RangeBounds}; #[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 { /// 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 fmt::Debug for Range { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { self.start.fmt(fmt)?; @@ -103,7 +103,7 @@ impl Range { /// 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 { self.clone().into_iter() @@ -132,7 +132,7 @@ impl> Range { /// 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(&self, item: &U) -> bool where @@ -164,7 +164,7 @@ impl> Range { /// 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 @@ impl> Range { } } -#[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 const RangeBounds for Range { fn start_bound(&self) -> Bound<&T> { @@ -191,7 +191,7 @@ impl const RangeBounds for Range { /// 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 const RangeBounds for Range<&T> { fn start_bound(&self) -> Bound<&T> { @@ -210,7 +210,7 @@ impl const IntoBounds for Range { } } -#[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 const From> for legacy::Range { #[inline] @@ -218,7 +218,7 @@ impl const From> for legacy::Range { 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 const From> for Range { #[inline] @@ -444,14 +444,14 @@ impl const From> for RangeInclusive { #[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 { /// 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 fmt::Debug for RangeFrom { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { self.start.fmt(fmt)?; @@ -475,7 +475,7 @@ impl RangeFrom { /// 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 { self.clone().into_iter() @@ -499,7 +499,7 @@ impl> RangeFrom { /// 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(&self, item: &U) -> bool where @@ -510,7 +510,7 @@ impl> RangeFrom { } } -#[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 const RangeBounds for RangeFrom { fn start_bound(&self) -> Bound<&T> { @@ -527,7 +527,7 @@ impl const RangeBounds for RangeFrom { /// 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 const RangeBounds for RangeFrom<&T> { fn start_bound(&self) -> Bound<&T> { @@ -557,7 +557,7 @@ where } } -#[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 const From> for legacy::RangeFrom { #[inline] @@ -565,7 +565,7 @@ impl const From> for legacy::RangeFrom { 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 const From> for RangeFrom { #[inline] @@ -619,14 +619,14 @@ impl const From> for RangeFrom { #[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 { /// 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 fmt::Debug for RangeToInclusive { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "..=")?; @@ -650,7 +650,7 @@ impl> RangeToInclusive { /// 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(&self, item: &U) -> bool where @@ -661,13 +661,13 @@ impl> RangeToInclusive { } } -#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")] impl From> for RangeToInclusive { fn from(value: legacy::RangeToInclusive) -> 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 From> for legacy::RangeToInclusive { fn from(value: RangeToInclusive) -> Self { Self { end: value.last } @@ -677,7 +677,7 @@ impl From> for legacy::RangeToInclusive { // RangeToInclusive cannot impl From> // 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 const RangeBounds for RangeToInclusive { fn start_bound(&self) -> Bound<&T> { @@ -688,7 +688,7 @@ impl const RangeBounds for RangeToInclusive { } } -#[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 const RangeBounds for RangeToInclusive<&T> { fn start_bound(&self) -> Bound<&T> { diff --git a/library/core/src/range/iter.rs b/library/core/src/range/iter.rs index a5db3699bc402..01b69554a0b1b 100644 --- a/library/core/src/range/iter.rs +++ b/library/core/src/range/iter.rs @@ -6,7 +6,7 @@ use crate::range::{Range, RangeFrom, RangeInclusive, legacy}; 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(legacy::Range); @@ -64,7 +64,7 @@ unsafe_range_trusted_random_access_impl! { u64 i64 } -#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_api", since = "1.96.0")] impl Iterator for RangeIter { type Item = A; @@ -132,7 +132,7 @@ impl Iterator for RangeIter { } } -#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_api", since = "1.96.0")] impl DoubleEndedIterator for RangeIter { #[inline] fn next_back(&mut self) -> Option { @@ -153,10 +153,10 @@ impl DoubleEndedIterator for RangeIter { #[unstable(feature = "trusted_len", issue = "37572")] unsafe impl TrustedLen for RangeIter {} -#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_api", since = "1.96.0")] impl FusedIterator for RangeIter {} -#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_api", since = "1.96.0")] impl IntoIterator for Range { type Item = A; type IntoIter = RangeIter; @@ -299,7 +299,7 @@ impl IntoIterator for RangeInclusive { // 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 @@ range_incl_exact_iter_impl! { } /// 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 { start: A, @@ -361,7 +361,7 @@ impl RangeFromIter { } } -#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_from_api", since = "1.96.0")] impl Iterator for RangeFromIter { type Item = A; @@ -432,10 +432,10 @@ impl Iterator for RangeFromIter { #[unstable(feature = "trusted_len", issue = "37572")] unsafe impl TrustedLen for RangeFromIter {} -#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_from_api", since = "1.96.0")] impl FusedIterator for RangeFromIter {} -#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "new_range_from_api", since = "1.96.0")] impl IntoIterator for RangeFrom { type Item = A; type IntoIter = RangeFromIter; diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs index f1727a1f629cb..0efe87a2d5368 100644 --- a/library/core/src/slice/index.rs +++ b/library/core/src/slice/index.rs @@ -125,13 +125,13 @@ mod private_slice_index { #[stable(feature = "slice_index_with_ops_bound_pair", since = "1.53.0")] impl Sealed for (ops::Bound, ops::Bound) {} - #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "new_range_api", since = "1.96.0")] impl Sealed for range::Range {} #[stable(feature = "new_range_inclusive_api", since = "1.95.0")] impl Sealed for range::RangeInclusive {} - #[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 {} - #[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 {} impl Sealed for ops::IndexRange {} @@ -458,7 +458,7 @@ unsafe impl const SliceIndex<[T]> for ops::Range { } } -#[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<[T]> for range::Range { type Output = [T]; @@ -588,7 +588,7 @@ unsafe impl const SliceIndex<[T]> for ops::RangeFrom { } } -#[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<[T]> for range::RangeFrom { type Output = [T]; @@ -801,7 +801,7 @@ unsafe impl const SliceIndex<[T]> for ops::RangeToInclusive { } /// 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 const SliceIndex<[T]> for range::RangeToInclusive { type Output = [T]; diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs index da0039f055fde..3b5cec22b69ea 100644 --- a/library/core/src/str/traits.rs +++ b/library/core/src/str/traits.rs @@ -258,7 +258,7 @@ unsafe impl const SliceIndex for ops::Range { } } -#[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 for range::Range { type Output = str; @@ -555,7 +555,7 @@ unsafe impl const SliceIndex for ops::RangeFrom { } } -#[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 for range::RangeFrom { type Output = str; @@ -777,7 +777,7 @@ unsafe impl const SliceIndex for ops::RangeToInclusive { /// 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 for range::RangeToInclusive { type Output = str; diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs index 9643d3fcae662..c75f005f18021 100644 --- a/library/std/src/fs.rs +++ b/library/std/src/fs.rs @@ -2896,7 +2896,7 @@ pub fn copy, Q: AsRef>(from: P, to: Q) -> io::Result { /// /// # 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 diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index 6b5d21e1046ff..2b347e5e8c286 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -545,7 +545,7 @@ pub use core::option; 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; diff --git a/library/std/src/sync/lazy_lock.rs b/library/std/src/sync/lazy_lock.rs index de1b9c391e8f2..2f2579e37aaf8 100644 --- a/library/std/src/sync/lazy_lock.rs +++ b/library/std/src/sync/lazy_lock.rs @@ -396,7 +396,7 @@ impl fmt::Debug for LazyLock { } } -#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "from_wrapper_impls", since = "1.96.0")] impl From for LazyLock { /// Constructs a `LazyLock` that starts already initialized /// with the provided value. diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs index 9b0ef5539d32b..5d2cfdf6718a1 100644 --- a/library/std/src/sys/fs/unix.rs +++ b/library/std/src/sys/fs/unix.rs @@ -339,7 +339,7 @@ fn get_path_from_fd(fd: c_int) -> Option { // 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_from_fd(fd: c_int) -> Option { #[cfg(target_os = "vxworks")] fn get_path(fd: c_int) -> Option { 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; } diff --git a/library/std/src/sys/paths/unix.rs b/library/std/src/sys/paths/unix.rs index 544d495340db7..616456c6d4a47 100644 --- a/library/std/src/sys/paths/unix.rs +++ b/library/std/src/sys/paths/unix.rs @@ -207,7 +207,7 @@ pub fn current_exe() -> io::Result { 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, diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs index a918ae929d2e0..c67981deda337 100644 --- a/src/bootstrap/src/core/build_steps/doc.rs +++ b/src/bootstrap/src/core/build_steps/doc.rs @@ -932,13 +932,7 @@ impl Step for Rustc { // 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"); diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs index c4a6b68aedee8..ca8af279b92bc 100644 --- a/src/bootstrap/src/core/sanity.rs +++ b/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 diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md index e19c7a8d4e44f..068e876d0fd8c 100644 --- a/src/doc/rustc-dev-guide/src/tests/compiletest.md +++ b/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. diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md index f160f3fffc10e..a9fe59e85d09d 100644 --- a/src/doc/rustc-dev-guide/src/tests/directives.md +++ b/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 diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 5fa5c7b0519ac..501420bdc88fc 100644 --- a/src/librustdoc/clean/mod.rs +++ b/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. diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 858545bd09847..2034abdfd1566 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -582,6 +582,7 @@ impl<'a, I: Iterator>> Iterator for HeadingLinks<'a, '_, } } 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 @@ impl<'a, I: Iterator>> Iterator for HeadingLinks<'a, '_, std::cmp::min(level as u32 + (self.heading_offset as u32), MAX_HEADER_LEVEL); self.buf.push_back((Event::Html(format!("").into()), 0..0)); - let start_tags = - format!("§"); + let start_tags = format!( + "§" + ); return Some((Event::Html(start_tags.into()), 0..0)); } event diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js index 491be052bca2e..8a72382cf90d4 100644 --- a/src/librustdoc/html/static/js/main.js +++ b/src/librustdoc/html/static/js/main.js @@ -2123,20 +2123,27 @@ function preLoadCss(cssUrl) { return; } but.onclick = () => { - // Most page titles are ' in - 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); - } - - copyContentToClipboard(path.join("::")); - copyButtonAnimation(but); + // 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"); + + 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); + } }; /** diff --git a/src/stage0 b/src/stage0 index 40be3f7a66a8a..4261ef43e8e6c 100644 --- a/src/stage0 +++ b/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 diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs index 036495130f819..e2a84eb76d9e5 100644 --- a/src/tools/compiletest/src/directives.rs +++ b/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, - // 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 @@ impl TestProps { 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 @@ impl TestProps { ); } - if self.should_ice { - self.failure_status = Some(101); - } - if config.mode == TestMode::Incremental { self.incremental = true; } diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs index 5421a97201737..34c6c1374b632 100644 --- a/src/tools/compiletest/src/directives/directive_names.rs +++ b/src/tools/compiletest/src/directives/directive_names.rs @@ -286,7 +286,6 @@ pub(crate) const KNOWN_DIRECTIVE_NAMES: &[&str] = &[ "rustc-env", "rustfix-only-machine-applicable", "should-fail", - "should-ice", "stderr-per-bitwidth", "test-mir-pass", "unique-doc-out-dir", diff --git a/src/tools/compiletest/src/directives/handlers.rs b/src/tools/compiletest/src/directives/handlers.rs index b53bda90f626b..5e6d2d49d7dcf 100644 --- a/src/tools/compiletest/src/directives/handlers.rs +++ b/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); }), diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index 455d7204d40eb..6b0ac39a357ec 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/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 @@ impl<'test> TestCx<'test> { } } - 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) { diff --git a/src/tools/compiletest/src/runtest/codegen_units.rs b/src/tools/compiletest/src/runtest/codegen_units.rs index 16c251c3c9e24..e4c924ed18a31 100644 --- a/src/tools/compiletest/src/runtest/codegen_units.rs +++ b/src/tools/compiletest/src/runtest/codegen_units.rs @@ -14,8 +14,6 @@ impl TestCx<'_> { 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 = "@@"; diff --git a/src/tools/compiletest/src/runtest/incremental.rs b/src/tools/compiletest/src/runtest/incremental.rs index 812f63625f983..47097c024246a 100644 --- a/src/tools/compiletest/src/runtest/incremental.rs +++ b/src/tools/compiletest/src/runtest/incremental.rs @@ -32,14 +32,8 @@ impl TestCx<'_> { } 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 @@ impl TestCx<'_> { 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) { diff --git a/tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs b/tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs index 11ee10e8cc333..4bf7fa12760b0 100644 --- a/tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs +++ b/tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs @@ -19,5 +19,6 @@ extern crate alloc; // 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) } } diff --git a/tests/debuginfo/basic-stepping.rs b/tests/debuginfo/basic-stepping.rs index a4410c70ba38a..f81c5cf7d3565 100644 --- a/tests/debuginfo/basic-stepping.rs +++ b/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"; diff --git a/tests/incremental/delayed_span_bug.rs b/tests/incremental/delayed_span_bug.rs index 7b409db2e18ea..ac14fc0f1b6d7 100644 --- a/tests/incremental/delayed_span_bug.rs +++ b/tests/incremental/delayed_span_bug.rs @@ -1,5 +1,5 @@ //@ revisions: cfail1 cfail2 -//@ should-ice +//@ failure-status: 101 #![feature(rustc_attrs)] diff --git a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs b/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs index c522ac46d918e..109fbb1c62036 100644 --- a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs +++ b/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs @@ -30,17 +30,17 @@ pub unsafe extern "C" fn check_list_1(mut ap: VaList) -> usize { continue_if!(ap.arg::() == '4' as c_int); continue_if!(ap.arg::() == ';' as c_int); continue_if!(ap.arg::() == 0x32); - continue_if!(ap.arg::() == 0x10000001); + continue_if!(ap.arg::() == 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::() == 3.14f64); + continue_if!(ap.arg::() == 3.14); continue_if!(ap.arg::() == 12); continue_if!(ap.arg::() == 'a' as c_int); - continue_if!(ap.arg::() == 6.28f64); + continue_if!(ap.arg::() == 6.28); continue_if!(compare_c_str(ap.arg::<*const c_char>(), c"Hello")); continue_if!(ap.arg::() == 42); continue_if!(compare_c_str(ap.arg::<*const c_char>(), c"World")); @@ -49,7 +49,7 @@ pub unsafe extern "C" fn check_list_2(mut ap: VaList) -> usize { #[unsafe(no_mangle)] pub unsafe extern "C" fn check_list_copy_0(mut ap: VaList) -> usize { - continue_if!(ap.arg::() == 6.28f64); + continue_if!(ap.arg::() == 6.28); continue_if!(ap.arg::() == 16); continue_if!(ap.arg::() == 'A' as c_int); continue_if!(compare_c_str(ap.arg::<*const c_char>(), c"Skip Me!")); @@ -66,7 +66,7 @@ pub unsafe extern "C" fn check_varargs_0(_: c_int, mut ap: ...) -> usize { #[unsafe(no_mangle)] pub unsafe extern "C" fn check_varargs_1(_: c_int, mut ap: ...) -> usize { - continue_if!(ap.arg::() == 3.14f64); + continue_if!(ap.arg::() == 3.14); continue_if!(ap.arg::() == 12); continue_if!(ap.arg::() == 'A' as c_int); continue_if!(ap.arg::() == 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) } } diff --git a/tests/run-make/c-link-to-rust-va-list-fn/test.c b/tests/run-make/c-link-to-rust-va-list-fn/test.c index 2bb93c0b5d0ef..b368302326c71 100644 --- a/tests/run-make/c-link-to-rust-va-list-fn/test.c +++ b/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); diff --git a/tests/rustdoc-gui/copy-path.goml b/tests/rustdoc-gui/copy-path.goml index e8766688f8d5e..61e63d7822c73 100644 --- a/tests/rustdoc-gui/copy-path.goml +++ b/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" diff --git a/tests/rustdoc-html/reexport/type-alias-reexport.rs b/tests/rustdoc-html/reexport/type-alias-reexport.rs new file mode 100644 index 0000000000000..1bcdff88e22c5 --- /dev/null +++ b/tests/rustdoc-html/reexport/type-alias-reexport.rs @@ -0,0 +1,34 @@ +// Regression test for . +// 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}; diff --git a/tests/rustdoc-html/unicode.rs b/tests/rustdoc-html/unicode.rs new file mode 100644 index 0000000000000..a961f178ec3b1 --- /dev/null +++ b/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() {} +} diff --git a/tests/ui/borrowck/borrowck-for-loop-deref-pattern-assignment.stderr b/tests/ui/borrowck/borrowck-for-loop-deref-pattern-assignment.stderr index fa230134df555..3c4d0e966136d 100644 --- a/tests/ui/borrowck/borrowck-for-loop-deref-pattern-assignment.stderr +++ b/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 diff --git a/tests/ui/borrowck/borrowck_for_loop_pattern_assignment.rs b/tests/ui/borrowck/borrowck_for_loop_pattern_assignment.rs new file mode 100644 index 0000000000000..93cbea820861d --- /dev/null +++ b/tests/ui/borrowck/borrowck_for_loop_pattern_assignment.rs @@ -0,0 +1,9 @@ +//! regression test for + +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}"); + } +} diff --git a/tests/ui/borrowck/borrowck_for_loop_pattern_assignment.stderr b/tests/ui/borrowck/borrowck_for_loop_pattern_assignment.stderr new file mode 100644 index 0000000000000..1dffe2b5e6436 --- /dev/null +++ b/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`. diff --git a/tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.rs b/tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.rs index d2aa61186bcd0..f29ec4bfe7dd8 100644 --- a/tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.rs +++ b/tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.rs @@ -9,6 +9,7 @@ impl Foo { 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] } } diff --git a/tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.stderr b/tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.stderr index 0a84848081d5c..c0e3f2ee5ddb2 100644 --- a/tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.stderr +++ b/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[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 5 previous errors +error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0425`. diff --git a/tests/ui/resolve/typo-suggestion-for-variable-with-name-similar-to-struct-field.stderr b/tests/ui/resolve/typo-suggestion-for-variable-with-name-similar-to-struct-field.stderr index 9c874d980cbe1..e7dcf2fdfe96d 100644 --- a/tests/ui/resolve/typo-suggestion-for-variable-with-name-similar-to-struct-field.stderr +++ b/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}"); diff --git a/triagebot.toml b/triagebot.toml index b0bf55a9248f4..953ef08a9cc8a 100644 --- a/triagebot.toml +++ b/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