diff options
306 files changed, 2995 insertions, 1668 deletions
diff --git a/Cargo.lock b/Cargo.lock index 10ebff84887..b480c42fa82 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -799,9 +799,9 @@ dependencies = [ [[package]] name = "compiler_builtins" -version = "0.1.78" +version = "0.1.79" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "413b6b13f725a46cdec40364e0c1d564a22cf0aaac5f1e267a129d956478a6b4" +checksum = "4f873ce2bd3550b0b565f878b3d04ea8253f4259dc3d20223af2e1ba86f5ecca" dependencies = [ "cc", "rustc-std-workspace-core", diff --git a/compiler/rustc_ast/src/lib.rs b/compiler/rustc_ast/src/lib.rs index 838f77512c5..528fc4816e9 100644 --- a/compiler/rustc_ast/src/lib.rs +++ b/compiler/rustc_ast/src/lib.rs @@ -14,7 +14,6 @@ #![feature(const_trait_impl)] #![feature(if_let_guard)] #![feature(label_break_value)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(min_specialization)] #![feature(negative_impls)] #![feature(slice_internals)] diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 38d30d0ffde..056f9ca08f8 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -31,7 +31,6 @@ //! in the HIR, especially for multiple identifiers. #![feature(box_patterns)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(never_type)] #![recursion_limit = "256"] diff --git a/compiler/rustc_ast_passes/src/lib.rs b/compiler/rustc_ast_passes/src/lib.rs index 2e3ac0c6018..2bc3b6f3616 100644 --- a/compiler/rustc_ast_passes/src/lib.rs +++ b/compiler/rustc_ast_passes/src/lib.rs @@ -8,7 +8,6 @@ #![feature(box_patterns)] #![feature(if_let_guard)] #![feature(iter_is_partitioned)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![recursion_limit = "256"] diff --git a/compiler/rustc_attr/src/lib.rs b/compiler/rustc_attr/src/lib.rs index afe1d191d10..c95c1c40a34 100644 --- a/compiler/rustc_attr/src/lib.rs +++ b/compiler/rustc_attr/src/lib.rs @@ -4,7 +4,6 @@ //! The goal is to move the definition of `MetaItem` and things that don't need to be in `syntax` //! to this crate. -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #[macro_use] diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs index 4f2a7bccefb..4ad9a970bc1 100644 --- a/compiler/rustc_borrowck/src/lib.rs +++ b/compiler/rustc_borrowck/src/lib.rs @@ -2,7 +2,6 @@ #![allow(rustc::potential_query_instability)] #![feature(box_patterns)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(min_specialization)] #![feature(never_type)] diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs index 0192f3c8ca4..48e81eb13c0 100644 --- a/compiler/rustc_builtin_macros/src/lib.rs +++ b/compiler/rustc_builtin_macros/src/lib.rs @@ -8,7 +8,6 @@ #![feature(decl_macro)] #![feature(if_let_guard)] #![feature(is_sorted)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(proc_macro_internals)] #![feature(proc_macro_quote)] diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs index eeb1ed61f28..c80ad692000 100644 --- a/compiler/rustc_codegen_llvm/src/lib.rs +++ b/compiler/rustc_codegen_llvm/src/lib.rs @@ -6,7 +6,6 @@ #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] #![feature(hash_raw_entry)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(extern_types)] #![feature(once_cell)] diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs index fc2e6652a3d..684877cae76 100644 --- a/compiler/rustc_const_eval/src/const_eval/machine.rs +++ b/compiler/rustc_const_eval/src/const_eval/machine.rs @@ -236,6 +236,16 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir, const PANIC_ON_ALLOC_FAIL: bool = false; // will be raised as a proper error + #[inline(always)] + fn enforce_alignment(ecx: &InterpCx<'mir, 'tcx, Self>) -> bool { + ecx.tcx.sess.opts.unstable_opts.extra_const_ub_checks + } + + #[inline(always)] + fn enforce_validity(ecx: &InterpCx<'mir, 'tcx, Self>) -> bool { + ecx.tcx.sess.opts.unstable_opts.extra_const_ub_checks + } + fn load_mir( ecx: &InterpCx<'mir, 'tcx, Self>, instance: ty::InstanceDef<'tcx>, diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs index 71ccd1799fa..9b9919fcc2a 100644 --- a/compiler/rustc_const_eval/src/interpret/machine.rs +++ b/compiler/rustc_const_eval/src/interpret/machine.rs @@ -437,24 +437,12 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) { type FrameExtra = (); #[inline(always)] - fn enforce_alignment(_ecx: &InterpCx<$mir, $tcx, Self>) -> bool { - // We do not check for alignment to avoid having to carry an `Align` - // in `ConstValue::ByRef`. - false - } - - #[inline(always)] fn force_int_for_alignment_check(_ecx: &InterpCx<$mir, $tcx, Self>) -> bool { // We do not support `force_int`. false } #[inline(always)] - fn enforce_validity(_ecx: &InterpCx<$mir, $tcx, Self>) -> bool { - false // for now, we don't enforce validity - } - - #[inline(always)] fn enforce_number_init(_ecx: &InterpCx<$mir, $tcx, Self>) -> bool { true } diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs index 6f6717721fb..f1b1855c3ec 100644 --- a/compiler/rustc_const_eval/src/interpret/validity.rs +++ b/compiler/rustc_const_eval/src/interpret/validity.rs @@ -1005,6 +1005,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { /// It will error if the bits at the destination do not match the ones described by the layout. #[inline(always)] pub fn validate_operand(&self, op: &OpTy<'tcx, M::Provenance>) -> InterpResult<'tcx> { + // Note that we *could* actually be in CTFE here with `-Zextra-const-ub-checks`, but it's + // still correct to not use `ctfe_mode`: that mode is for validation of the final constant + // value, it rules out things like `UnsafeCell` in awkward places. It also can make checking + // recurse through references which, for now, we don't want here, either. self.validate_operand_internal(op, vec![], None, None) } } diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs index 1063f03d0e2..7272ae5aa09 100644 --- a/compiler/rustc_const_eval/src/lib.rs +++ b/compiler/rustc_const_eval/src/lib.rs @@ -9,7 +9,6 @@ Rust MIR: a lowered representation of Rust. #![feature(control_flow_enum)] #![feature(decl_macro)] #![feature(exact_size_is_empty)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(map_try_insert)] #![feature(min_specialization)] diff --git a/compiler/rustc_const_eval/src/transform/promote_consts.rs b/compiler/rustc_const_eval/src/transform/promote_consts.rs index ed4d8c95d1e..161c89e3242 100644 --- a/compiler/rustc_const_eval/src/transform/promote_consts.rs +++ b/compiler/rustc_const_eval/src/transform/promote_consts.rs @@ -839,17 +839,12 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> { let mut promoted_operand = |ty, span| { promoted.span = span; promoted.local_decls[RETURN_PLACE] = LocalDecl::new(ty, span); + let substs = tcx.erase_regions(InternalSubsts::identity_for_item(tcx, def.did)); let _const = tcx.mk_const(ty::ConstS { ty, kind: ty::ConstKind::Unevaluated(ty::Unevaluated { def, - substs: InternalSubsts::for_item(tcx, def.did, |param, _| { - if let ty::GenericParamDefKind::Lifetime = param.kind { - tcx.lifetimes.re_erased.into() - } else { - tcx.mk_param_from_def(param) - } - }), + substs, promoted: Some(promoted_id), }), }); diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs index 2ac5c1960cd..9e73a399809 100644 --- a/compiler/rustc_error_messages/src/lib.rs +++ b/compiler/rustc_error_messages/src/lib.rs @@ -1,4 +1,3 @@ -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(once_cell)] #![feature(rustc_attrs)] #![feature(type_alias_impl_trait)] diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs index 61d953cd6f1..753e2f07c04 100644 --- a/compiler/rustc_errors/src/emitter.rs +++ b/compiler/rustc_errors/src/emitter.rs @@ -273,40 +273,58 @@ pub trait Emitter { DiagnosticMessage::FluentIdentifier(identifier, attr) => (identifier, attr), }; - let bundle = match self.fluent_bundle() { - Some(bundle) if bundle.has_message(&identifier) => bundle, - _ => self.fallback_fluent_bundle(), - }; + let translate_with_bundle = |bundle: &'a FluentBundle| -> Option<(Cow<'_, str>, Vec<_>)> { + let message = bundle.get_message(&identifier)?; + let value = match attr { + Some(attr) => message.get_attribute(attr)?.value(), + None => message.value()?, + }; + debug!(?message, ?value); - let message = bundle.get_message(&identifier).expect("missing diagnostic in fluent bundle"); - let value = match attr { - Some(attr) => { - if let Some(attr) = message.get_attribute(attr) { - attr.value() - } else { - panic!("missing attribute `{attr}` in fluent message `{identifier}`") - } - } - None => { - if let Some(value) = message.value() { - value - } else { - panic!("missing value in fluent message `{identifier}`") - } - } + let mut errs = vec![]; + let translated = bundle.format_pattern(value, Some(&args), &mut errs); + debug!(?translated, ?errs); + Some((translated, errs)) }; - let mut err = vec![]; - let translated = bundle.format_pattern(value, Some(&args), &mut err); - trace!(?translated, ?err); - debug_assert!( - err.is_empty(), - "identifier: {:?}, args: {:?}, errors: {:?}", - identifier, - args, - err - ); - translated + self.fluent_bundle() + .and_then(|bundle| translate_with_bundle(bundle)) + // If `translate_with_bundle` returns `None` with the primary bundle, this is likely + // just that the primary bundle doesn't contain the message being translated, so + // proceed to the fallback bundle. + // + // However, when errors are produced from translation, then that means the translation + // is broken (e.g. `{$foo}` exists in a translation but `foo` isn't provided). + // + // In debug builds, assert so that compiler devs can spot the broken translation and + // fix it.. + .inspect(|(_, errs)| { + debug_assert!( + errs.is_empty(), + "identifier: {:?}, attr: {:?}, args: {:?}, errors: {:?}", + identifier, + attr, + args, + errs + ); + }) + // ..otherwise, for end users, an error about this wouldn't be useful or actionable, so + // just hide it and try with the fallback bundle. + .filter(|(_, errs)| errs.is_empty()) + .or_else(|| translate_with_bundle(self.fallback_fluent_bundle())) + .map(|(translated, errs)| { + // Always bail out for errors with the fallback bundle. + assert!( + errs.is_empty(), + "identifier: {:?}, attr: {:?}, args: {:?}, errors: {:?}", + identifier, + attr, + args, + errs + ); + translated + }) + .expect("failed to find message in primary or fallback fluent bundles") } /// Formats the substitutions of the primary_span diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index 15c1858023d..d2eb4f212eb 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -5,10 +5,10 @@ #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] #![feature(drain_filter)] #![feature(if_let_guard)] -#![cfg_attr(bootstrap, feature(let_chains))] +#![feature(adt_const_params)] #![feature(let_else)] #![feature(never_type)] -#![feature(adt_const_params)] +#![feature(result_option_inspect)] #![feature(rustc_attrs)] #![allow(incomplete_features)] #![allow(rustc::potential_query_instability)] diff --git a/compiler/rustc_expand/src/lib.rs b/compiler/rustc_expand/src/lib.rs index 20d01b6dc26..91a18342784 100644 --- a/compiler/rustc_expand/src/lib.rs +++ b/compiler/rustc_expand/src/lib.rs @@ -2,7 +2,6 @@ #![feature(associated_type_bounds)] #![feature(associated_type_defaults)] #![feature(if_let_guard)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(macro_metavar_expr)] #![feature(proc_macro_diagnostic)] diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index e0179bd3ed1..c7966b662de 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -911,6 +911,10 @@ impl<'a> State<'a> { if let Some(els) = els { self.nbsp(); self.word_space("else"); + // containing cbox, will be closed by print-block at `}` + self.cbox(0); + // head-box, will be closed by print-block after `{` + self.ibox(0); self.print_block(els); } diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs index 20864c657ff..772b81992c4 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs @@ -1424,7 +1424,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { /// E0271, like `src/test/ui/issues/issue-39970.stderr`. #[tracing::instrument( level = "debug", - skip(self, diag, secondary_span, swap_secondary_and_primary, force_label) + skip(self, diag, secondary_span, swap_secondary_and_primary, prefer_label) )] pub fn note_type_err( &self, @@ -1434,7 +1434,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { mut values: Option<ValuePairs<'tcx>>, terr: &TypeError<'tcx>, swap_secondary_and_primary: bool, - force_label: bool, + prefer_label: bool, ) { let span = cause.span(); @@ -1612,7 +1612,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { TypeError::ObjectUnsafeCoercion(_) => {} _ => { let mut label_or_note = |span: Span, msg: &str| { - if force_label || &[span] == diag.span.primary_spans() { + if (prefer_label && is_simple_error) || &[span] == diag.span.primary_spans() { diag.span_label(span, msg); } else { diag.span_note(span, msg); diff --git a/compiler/rustc_infer/src/lib.rs b/compiler/rustc_infer/src/lib.rs index 490ba52503f..1c515f5ee57 100644 --- a/compiler/rustc_infer/src/lib.rs +++ b/compiler/rustc_infer/src/lib.rs @@ -18,7 +18,6 @@ #![feature(control_flow_enum)] #![feature(extend_one)] #![feature(label_break_value)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(min_specialization)] #![feature(never_type)] diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs index 94f81b66077..dc4799e4afc 100644 --- a/compiler/rustc_interface/src/interface.rs +++ b/compiler/rustc_interface/src/interface.rs @@ -330,7 +330,7 @@ pub fn create_compiler_and_run<R>(config: Config, f: impl FnOnce(&Compiler) -> R } // JUSTIFICATION: before session exists, only config -#[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] +#[allow(rustc::bad_opt_access)] pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Send) -> R { tracing::trace!("run_compiler"); util::run_in_thread_pool_with_globals( diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs index a9fdfa24141..9207a048862 100644 --- a/compiler/rustc_interface/src/tests.rs +++ b/compiler/rustc_interface/src/tests.rs @@ -1,4 +1,4 @@ -#![cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] +#![allow(rustc::bad_opt_access)] use crate::interface::parse_cfgspecs; use rustc_data_structures::fx::FxHashSet; diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs index 5e5596f13c8..e74978485a2 100644 --- a/compiler/rustc_interface/src/util.rs +++ b/compiler/rustc_interface/src/util.rs @@ -559,7 +559,7 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<C // command line, then reuse the empty `base` Vec to hold the types that // will be found in crate attributes. // JUSTIFICATION: before wrapper fn is available - #[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] + #[allow(rustc::bad_opt_access)] let mut base = session.opts.crate_types.clone(); if base.is_empty() { base.extend(attr_types); diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs index ae2088fbeb6..f087c624917 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -33,7 +33,6 @@ #![feature(if_let_guard)] #![feature(iter_intersperse)] #![feature(iter_order_by)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(never_type)] #![recursion_limit = "256"] diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs index e192378bcc3..75069a5f0dc 100644 --- a/compiler/rustc_metadata/src/lib.rs +++ b/compiler/rustc_metadata/src/lib.rs @@ -4,7 +4,6 @@ #![feature(generators)] #![feature(generic_associated_types)] #![feature(iter_from_generator)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(once_cell)] #![feature(proc_macro_internals)] diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index 4e1254efd17..6a6505d0256 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -39,7 +39,6 @@ #![feature(extern_types)] #![feature(new_uninit)] #![feature(once_cell)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(min_specialization)] #![feature(trusted_len)] diff --git a/compiler/rustc_mir_build/src/lib.rs b/compiler/rustc_mir_build/src/lib.rs index a7d8431b6c7..e51ca65dc16 100644 --- a/compiler/rustc_mir_build/src/lib.rs +++ b/compiler/rustc_mir_build/src/lib.rs @@ -5,7 +5,6 @@ #![feature(box_patterns)] #![feature(control_flow_enum)] #![feature(if_let_guard)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(min_specialization)] #![feature(once_cell)] diff --git a/compiler/rustc_mir_transform/src/const_prop.rs b/compiler/rustc_mir_transform/src/const_prop.rs index 98016659a05..1c087b93b49 100644 --- a/compiler/rustc_mir_transform/src/const_prop.rs +++ b/compiler/rustc_mir_transform/src/const_prop.rs @@ -183,6 +183,18 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for ConstPropMachine<'mir, 'tcx> type MemoryKind = !; + #[inline(always)] + fn enforce_alignment(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool { + // We do not check for alignment to avoid having to carry an `Align` + // in `ConstValue::ByRef`. + false + } + + #[inline(always)] + fn enforce_validity(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool { + false // for now, we don't enforce validity + } + fn load_mir( _ecx: &InterpCx<'mir, 'tcx, Self>, _instance: ty::InstanceDef<'tcx>, diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs index 2a51af582f5..56fb601d2b5 100644 --- a/compiler/rustc_mir_transform/src/lib.rs +++ b/compiler/rustc_mir_transform/src/lib.rs @@ -1,6 +1,5 @@ #![allow(rustc::potential_query_instability)] #![feature(box_patterns)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(map_try_insert)] #![feature(min_specialization)] diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs index 261adbfc346..5924eba9f8b 100644 --- a/compiler/rustc_parse/src/lib.rs +++ b/compiler/rustc_parse/src/lib.rs @@ -3,7 +3,6 @@ #![feature(array_windows)] #![feature(box_patterns)] #![feature(if_let_guard)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(never_type)] #![feature(rustc_attrs)] diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs index 2880ef78c8d..33bebfc2c9a 100644 --- a/compiler/rustc_parse/src/parser/expr.rs +++ b/compiler/rustc_parse/src/parser/expr.rs @@ -2268,7 +2268,7 @@ impl<'a> Parser<'a> { attrs: attrs.into(), ty, pat, - span: lo.to(this.token.span), + span: lo.to(this.prev_token.span), id: DUMMY_NODE_ID, is_placeholder: false, }, diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs index 72c23776d33..83fab0829a1 100644 --- a/compiler/rustc_parse/src/parser/item.rs +++ b/compiler/rustc_parse/src/parser/item.rs @@ -68,7 +68,12 @@ impl<'a> Parser<'a> { if !self.maybe_consume_incorrect_semicolon(&items) { let msg = &format!("expected item, found {token_str}"); let mut err = self.struct_span_err(self.token.span, msg); - err.span_label(self.token.span, "expected item"); + let label = if self.is_kw_followed_by_ident(kw::Let) { + "consider using `const` or `static` instead of `let` for global variables" + } else { + "expected item" + }; + err.span_label(self.token.span, label); return Err(err); } } @@ -670,14 +675,44 @@ impl<'a> Parser<'a> { } match parse_item(self) { Ok(None) => { + let is_unnecessary_semicolon = !items.is_empty() + // When the close delim is `)` in a case like the following, `token.kind` is expected to be `token::CloseDelim(Delimiter::Parenthesis)`, + // but the actual `token.kind` is `token::CloseDelim(Delimiter::Bracket)`. + // This is because the `token.kind` of the close delim is treated as the same as + // that of the open delim in `TokenTreesReader::parse_token_tree`, even if the delimiters of them are different. + // Therefore, `token.kind` should not be compared here. + // + // issue-60075.rs + // ``` + // trait T { + // fn qux() -> Option<usize> { + // let _ = if true { + // }); + // ^ this close delim + // Some(4) + // } + // ``` + && self + .span_to_snippet(self.prev_token.span) + .map_or(false, |snippet| snippet == "}") + && self.token.kind == token::Semi; + let semicolon_span = self.token.span; // We have to bail or we'll potentially never make progress. let non_item_span = self.token.span; self.consume_block(Delimiter::Brace, ConsumeClosingDelim::Yes); - self.struct_span_err(non_item_span, "non-item in item list") - .span_label(open_brace_span, "item list starts here") + let mut err = self.struct_span_err(non_item_span, "non-item in item list"); + err.span_label(open_brace_span, "item list starts here") .span_label(non_item_span, "non-item starts here") - .span_label(self.prev_token.span, "item list ends here") - .emit(); + .span_label(self.prev_token.span, "item list ends here"); + if is_unnecessary_semicolon { + err.span_suggestion( + semicolon_span, + "consider removing this semicolon", + "", + Applicability::MaybeIncorrect, + ); + } + err.emit(); break; } Ok(Some(item)) => items.extend(item), @@ -1127,6 +1162,16 @@ impl<'a> Parser<'a> { Applicability::MaybeIncorrect, ) .emit(); + } else if self.eat_keyword(kw::Let) { + let span = self.prev_token.span; + self.struct_span_err(const_span.to(span), "`const` and `let` are mutually exclusive") + .span_suggestion( + const_span.to(span), + "remove `let`", + "const", + Applicability::MaybeIncorrect, + ) + .emit(); } } @@ -1539,8 +1584,12 @@ impl<'a> Parser<'a> { } } - if self.token.is_ident() { - // This is likely another field; emit the diagnostic and keep going + if self.token.is_ident() + || (self.token.kind == TokenKind::Pound + && (self.look_ahead(1, |t| t == &token::OpenDelim(Delimiter::Bracket)))) + { + // This is likely another field, TokenKind::Pound is used for `#[..]` attribute for next field, + // emit the diagnostic and keep going err.span_suggestion( sp, "try adding a comma", diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs index 51bd9d2d386..6990d0782b7 100644 --- a/compiler/rustc_parse/src/parser/stmt.rs +++ b/compiler/rustc_parse/src/parser/stmt.rs @@ -247,6 +247,22 @@ impl<'a> Parser<'a> { /// Parses a local variable declaration. fn parse_local(&mut self, attrs: AttrVec) -> PResult<'a, P<Local>> { let lo = self.prev_token.span; + + if self.token.is_keyword(kw::Const) && self.look_ahead(1, |t| t.is_ident()) { + self.struct_span_err( + lo.to(self.token.span), + "`const` and `let` are mutually exclusive", + ) + .span_suggestion( + lo.to(self.token.span), + "remove `let`", + "const", + Applicability::MaybeIncorrect, + ) + .emit(); + self.bump(); + } + let (pat, colon) = self.parse_pat_before_ty(None, RecoverComma::Yes, "`let` bindings")?; let (err, ty) = if colon { diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs index defa9d15296..4af041dac0d 100644 --- a/compiler/rustc_passes/src/lib.rs +++ b/compiler/rustc_passes/src/lib.rs @@ -7,7 +7,6 @@ #![allow(rustc::potential_query_instability)] #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] #![feature(iter_intersperse)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(map_try_insert)] #![feature(min_specialization)] diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index 574e8073d8e..f884e04a951 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -460,7 +460,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> { AnnotationKind::Required, InheritDeprecation::Yes, InheritConstStability::No, - InheritStability::No, + InheritStability::Yes, |_| {}, ); } @@ -600,6 +600,9 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { fn visit_variant(&mut self, var: &'tcx Variant<'tcx>) { self.check_missing_stability(self.tcx.hir().local_def_id(var.id), var.span); + if let Some(ctor_hir_id) = var.data.ctor_hir_id() { + self.check_missing_stability(self.tcx.hir().local_def_id(ctor_hir_id), var.span); + } intravisit::walk_variant(self, var); } @@ -962,58 +965,113 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) { remaining_lib_features.remove(&sym::libc); remaining_lib_features.remove(&sym::test); - // We always collect the lib features declared in the current crate, even if there are - // no unknown features, because the collection also does feature attribute validation. - let local_defined_features = tcx.lib_features(()); - let mut all_lib_features: FxHashMap<_, _> = - local_defined_features.to_vec().iter().map(|el| *el).collect(); - let mut implications = tcx.stability_implications(rustc_hir::def_id::LOCAL_CRATE).clone(); - for &cnum in tcx.crates(()) { - implications.extend(tcx.stability_implications(cnum)); - all_lib_features.extend(tcx.defined_lib_features(cnum).iter().map(|el| *el)); - } - - // Check that every feature referenced by an `implied_by` exists (for features defined in the - // local crate). - for (implied_by, feature) in tcx.stability_implications(rustc_hir::def_id::LOCAL_CRATE) { - // Only `implied_by` needs to be checked, `feature` is guaranteed to exist. - if !all_lib_features.contains_key(implied_by) { - let span = local_defined_features - .stable - .get(feature) - .map(|(_, span)| span) - .or_else(|| local_defined_features.unstable.get(feature)) - .expect("feature that implied another does not exist"); - tcx.sess - .struct_span_err( - *span, - format!("feature `{implied_by}` implying `{feature}` does not exist"), - ) - .emit(); - } - } - - if !remaining_lib_features.is_empty() { - for (feature, since) in all_lib_features.iter() { + /// For each feature in `defined_features`.. + /// + /// - If it is in `remaining_lib_features` (those features with `#![feature(..)]` attributes in + /// the current crate), check if it is stable (or partially stable) and thus an unnecessary + /// attribute. + /// - If it is in `remaining_implications` (a feature that is referenced by an `implied_by` + /// from the current crate), then remove it from the remaining implications. + /// + /// Once this function has been invoked for every feature (local crate and all extern crates), + /// then.. + /// + /// - If features remain in `remaining_lib_features`, then the user has enabled a feature that + /// does not exist. + /// - If features remain in `remaining_implications`, the `implied_by` refers to a feature that + /// does not exist. + /// + /// By structuring the code in this way: checking the features defined from each crate one at a + /// time, less loading from metadata is performed and thus compiler performance is improved. + fn check_features<'tcx>( + tcx: TyCtxt<'tcx>, + remaining_lib_features: &mut FxIndexMap<&Symbol, Span>, + remaining_implications: &mut FxHashMap<Symbol, Symbol>, + defined_features: &[(Symbol, Option<Symbol>)], + all_implications: &FxHashMap<Symbol, Symbol>, + ) { + for (feature, since) in defined_features { if let Some(since) = since && let Some(span) = remaining_lib_features.get(&feature) { // Warn if the user has enabled an already-stable lib feature. - if let Some(implies) = implications.get(&feature) { + if let Some(implies) = all_implications.get(&feature) { unnecessary_partially_stable_feature_lint(tcx, *span, *feature, *implies, *since); } else { unnecessary_stable_feature_lint(tcx, *span, *feature, *since); } + } - remaining_lib_features.remove(&feature); - if remaining_lib_features.is_empty() { + remaining_lib_features.remove(feature); + + // `feature` is the feature doing the implying, but `implied_by` is the feature with + // the attribute that establishes this relationship. `implied_by` is guaranteed to be a + // feature defined in the local crate because `remaining_implications` is only the + // implications from this crate. + remaining_implications.remove(feature); + + if remaining_lib_features.is_empty() && remaining_implications.is_empty() { break; } } } + // All local crate implications need to have the feature that implies it confirmed to exist. + let mut remaining_implications = + tcx.stability_implications(rustc_hir::def_id::LOCAL_CRATE).clone(); + + // We always collect the lib features declared in the current crate, even if there are + // no unknown features, because the collection also does feature attribute validation. + let local_defined_features = tcx.lib_features(()).to_vec(); + if !remaining_lib_features.is_empty() || !remaining_implications.is_empty() { + // Loading the implications of all crates is unavoidable to be able to emit the partial + // stabilization diagnostic, but it can be avoided when there are no + // `remaining_lib_features`. + let mut all_implications = remaining_implications.clone(); + for &cnum in tcx.crates(()) { + all_implications.extend(tcx.stability_implications(cnum)); + } + + check_features( + tcx, + &mut remaining_lib_features, + &mut remaining_implications, + local_defined_features.as_slice(), + &all_implications, + ); + + for &cnum in tcx.crates(()) { + if remaining_lib_features.is_empty() && remaining_implications.is_empty() { + break; + } + check_features( + tcx, + &mut remaining_lib_features, + &mut remaining_implications, + tcx.defined_lib_features(cnum).to_vec().as_slice(), + &all_implications, + ); + } + } + for (feature, span) in remaining_lib_features { struct_span_err!(tcx.sess, span, E0635, "unknown feature `{}`", feature).emit(); } + for (implied_by, feature) in remaining_implications { + let local_defined_features = tcx.lib_features(()); + let span = local_defined_features + .stable + .get(&feature) + .map(|(_, span)| span) + .or_else(|| local_defined_features.unstable.get(&feature)) + .expect("feature that implied another does not exist"); + tcx.sess + .struct_span_err( + *span, + format!("feature `{implied_by}` implying `{feature}` does not exist"), + ) + .emit(); + } + // FIXME(#44232): the `used_features` table no longer exists, so we // don't lint about unused features. We should re-enable this one day! } diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index f7c28eff55b..27fa402edce 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -5,8 +5,8 @@ #![feature(try_blocks)] #![recursion_limit = "256"] #![allow(rustc::potential_query_instability)] -#![cfg_attr(not(bootstrap), deny(rustc::untranslatable_diagnostic))] -#![cfg_attr(not(bootstrap), deny(rustc::diagnostic_outside_of_impl))] +#![deny(rustc::untranslatable_diagnostic)] +#![deny(rustc::diagnostic_outside_of_impl)] mod errors; diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs index cb133841bca..09c1f44826f 100644 --- a/compiler/rustc_resolve/src/late/diagnostics.rs +++ b/compiler/rustc_resolve/src/late/diagnostics.rs @@ -985,27 +985,45 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> { let ns = source.namespace(); let is_expected = &|res| source.is_expected(res); - let path_sep = |err: &mut Diagnostic, expr: &Expr| match expr.kind { - ExprKind::Field(_, ident) => { + let path_sep = |err: &mut Diagnostic, expr: &Expr, kind: DefKind| { + const MESSAGE: &str = "use the path separator to refer to an item"; + + let (lhs_span, rhs_span) = match &expr.kind { + ExprKind::Field(base, ident) => (base.span, ident.span), + ExprKind::MethodCall(_, receiver, _, span) => (receiver.span, *span), + _ => return false, + }; + + if lhs_span.eq_ctxt(rhs_span) { err.span_suggestion( - expr.span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, ident), + lhs_span.between(rhs_span), + MESSAGE, + "::", Applicability::MaybeIncorrect, ); true - } - ExprKind::MethodCall(ref segment, ..) => { - let span = expr.span.with_hi(segment.ident.span.hi()); - err.span_suggestion( - span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, segment.ident), + } else if kind == DefKind::Struct + && let Some(lhs_source_span) = lhs_span.find_ancestor_inside(expr.span) + && let Ok(snippet) = self.r.session.source_map().span_to_snippet(lhs_source_span) + { + // The LHS is a type that originates from a macro call. + // We have to add angle brackets around it. + + err.span_suggestion_verbose( + lhs_source_span.until(rhs_span), + MESSAGE, + format!("<{snippet}>::"), Applicability::MaybeIncorrect, ); true + } else { + // Either we were unable to obtain the source span / the snippet or + // the LHS originates from a macro call and it is not a type and thus + // there is no way to replace `.` with `::` and still somehow suggest + // valid Rust code. + + false } - _ => false, }; let find_span = |source: &PathSource<'_>, err: &mut Diagnostic| { @@ -1027,7 +1045,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> { match source { PathSource::Expr(Some( parent @ Expr { kind: ExprKind::Field(..) | ExprKind::MethodCall(..), .. }, - )) if path_sep(err, &parent) => {} + )) if path_sep(err, &parent, DefKind::Struct) => {} PathSource::Expr( None | Some(Expr { @@ -1143,8 +1161,11 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> { } } } - (Res::Def(DefKind::Mod, _), PathSource::Expr(Some(parent))) => { - if !path_sep(err, &parent) { + ( + Res::Def(kind @ (DefKind::Mod | DefKind::Trait), _), + PathSource::Expr(Some(parent)), + ) => { + if !path_sep(err, &parent, kind) { return false; } } diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs index ef3c3da89c5..9c213da8c2a 100644 --- a/compiler/rustc_resolve/src/lib.rs +++ b/compiler/rustc_resolve/src/lib.rs @@ -10,7 +10,6 @@ #![feature(box_patterns)] #![feature(drain_filter)] #![feature(if_let_guard)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(iter_intersperse)] #![feature(let_else)] #![feature(never_type)] diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 6a8298605a2..68519c8fa82 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -949,7 +949,7 @@ fn default_configuration(sess: &Session) -> CrateConfig { ret.insert((sym::debug_assertions, None)); } // JUSTIFICATION: before wrapper fn is available - #[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] + #[allow(rustc::bad_opt_access)] if sess.opts.crate_types.contains(&CrateType::ProcMacro) { ret.insert((sym::proc_macro, None)); } @@ -2198,7 +2198,7 @@ fn parse_remap_path_prefix( } // JUSTIFICATION: before wrapper fn is available -#[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] +#[allow(rustc::bad_opt_access)] pub fn build_session_options(matches: &getopts::Matches) -> Options { let color = parse_color(matches); diff --git a/compiler/rustc_session/src/lib.rs b/compiler/rustc_session/src/lib.rs index 44cf5048642..0617bd5fae7 100644 --- a/compiler/rustc_session/src/lib.rs +++ b/compiler/rustc_session/src/lib.rs @@ -1,5 +1,4 @@ #![feature(if_let_guard)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(min_specialization)] #![feature(never_type)] diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 1827f1c208d..63ae91f8e6c 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -127,11 +127,11 @@ top_level_options!( /// `CodegenOptions`, think about how it influences incremental compilation. If in /// doubt, specify `[TRACKED]`, which is always "correct" but might lead to /// unnecessary re-compilation. - #[cfg_attr(not(bootstrap), rustc_lint_opt_ty)] + #[rustc_lint_opt_ty] pub struct Options { /// The crate config requested for the session, which may be combined /// with additional crate configurations during the compile process. - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::crate_types` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::crate_types` instead of this field")] crate_types: Vec<CrateType> [TRACKED], optimize: OptLevel [TRACKED], /// Include the `debug_assertions` flag in dependency tracking, since it @@ -178,9 +178,9 @@ top_level_options!( /// what rustc was invoked with, but massaged a bit to agree with /// commands like `--emit llvm-ir` which they're often incompatible with /// if we otherwise use the defaults of rustc. - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::codegen_units` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::codegen_units` instead of this field")] cli_forced_codegen_units: Option<usize> [UNTRACKED], - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field")] cli_forced_thinlto_off: bool [UNTRACKED], /// Remap source path prefixes in all output (messages, object files, debug, etc.). @@ -231,7 +231,7 @@ macro_rules! options { ),* ,) => ( #[derive(Clone)] - #[cfg_attr(not(bootstrap), rustc_lint_opt_ty)] + #[rustc_lint_opt_ty] pub struct $struct_name { $( $( #[$attr] )* pub $opt: $t),* } impl Default for $struct_name { @@ -282,7 +282,7 @@ macro_rules! options { impl Options { // JUSTIFICATION: defn of the suggested wrapper fn - #[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] + #[allow(rustc::bad_opt_access)] pub fn time_passes(&self) -> bool { self.unstable_opts.time_passes || self.unstable_opts.time } @@ -290,7 +290,7 @@ impl Options { impl CodegenOptions { // JUSTIFICATION: defn of the suggested wrapper fn - #[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] + #[allow(rustc::bad_opt_access)] pub fn instrument_coverage(&self) -> InstrumentCoverage { self.instrument_coverage.unwrap_or(InstrumentCoverage::Off) } @@ -1091,7 +1091,7 @@ options! { ar: String = (String::new(), parse_string, [UNTRACKED], "this option is deprecated and does nothing"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::code_model` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::code_model` instead of this field")] code_model: Option<CodeModel> = (None, parse_code_model, [TRACKED], "choose the code model to use (`rustc --print code-models` for details)"), codegen_units: Option<usize> = (None, parse_opt_number, [UNTRACKED], @@ -1111,14 +1111,14 @@ options! { "extra data to put in each output filename"), force_frame_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED], "force use of the frame pointers"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::must_emit_unwind_tables` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::must_emit_unwind_tables` instead of this field")] force_unwind_tables: Option<bool> = (None, parse_opt_bool, [TRACKED], "force use of unwind tables"), incremental: Option<String> = (None, parse_opt_string, [UNTRACKED], "enable incremental compilation"), inline_threshold: Option<u32> = (None, parse_opt_number, [TRACKED], "set the threshold for inlining a function"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::instrument_coverage` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::instrument_coverage` instead of this field")] instrument_coverage: Option<InstrumentCoverage> = (None, parse_instrument_coverage, [TRACKED], "instrument the generated code to support LLVM source-based code coverage \ reports (note, the compiler build config must include `profiler = true`); \ @@ -1131,7 +1131,7 @@ options! { "a single extra argument to append to the linker invocation (can be used several times)"), link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED], "extra arguments to append to the linker invocation (space separated)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::link_dead_code` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::link_dead_code` instead of this field")] link_dead_code: Option<bool> = (None, parse_opt_bool, [TRACKED], "keep dead code at link time (useful for code coverage) (default: no)"), link_self_contained: Option<bool> = (None, parse_opt_bool, [UNTRACKED], @@ -1146,7 +1146,7 @@ options! { "generate build artifacts that are compatible with linker-based LTO"), llvm_args: Vec<String> = (Vec::new(), parse_list, [TRACKED], "a list of arguments to pass to LLVM (space separated)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field")] lto: LtoCli = (LtoCli::Unspecified, parse_lto, [TRACKED], "perform LLVM link-time optimizations"), metadata: Vec<String> = (Vec::new(), parse_list, [TRACKED], @@ -1163,10 +1163,10 @@ options! { "disable LLVM's SLP vectorization pass"), opt_level: String = ("0".to_string(), parse_string, [TRACKED], "optimization level (0-3, s, or z; default: 0)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::overflow_checks` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::overflow_checks` instead of this field")] overflow_checks: Option<bool> = (None, parse_opt_bool, [TRACKED], "use overflow checks for integer arithmetic"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::panic_strategy` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::panic_strategy` instead of this field")] panic: Option<PanicStrategy> = (None, parse_opt_panic_strategy, [TRACKED], "panic strategy to compile crate with"), passes: Vec<String> = (Vec::new(), parse_list, [TRACKED], @@ -1178,7 +1178,7 @@ options! { "compile the program with profiling instrumentation"), profile_use: Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED], "use the given `.profdata` file for profile-guided optimization"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::relocation_model` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::relocation_model` instead of this field")] relocation_model: Option<RelocModel> = (None, parse_relocation_model, [TRACKED], "control generation of position-independent code (PIC) \ (`rustc --print relocation-models` for details)"), @@ -1190,7 +1190,7 @@ options! { "save all temporary output files during compilation (default: no)"), soft_float: bool = (false, parse_bool, [TRACKED], "use soft float ABI (*eabihf targets only) (default: no)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::split_debuginfo` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::split_debuginfo` instead of this field")] split_debuginfo: Option<SplitDebuginfo> = (None, parse_split_debuginfo, [TRACKED], "how to handle split-debuginfo, a platform-specific option"), strip: Strip = (Strip::None, parse_strip, [UNTRACKED], @@ -1226,13 +1226,13 @@ options! { "encode MIR of all functions into the crate metadata (default: no)"), assume_incomplete_release: bool = (false, parse_bool, [TRACKED], "make cfg(version) treat the current version as incomplete (default: no)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::asm_comments` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::asm_comments` instead of this field")] asm_comments: bool = (false, parse_bool, [TRACKED], "generate comments into the assembly (may change behavior) (default: no)"), assert_incr_state: Option<String> = (None, parse_opt_string, [UNTRACKED], "assert that the incremental cache is in given state: \ either `loaded` or `not-loaded`."), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::binary_dep_depinfo` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::binary_dep_depinfo` instead of this field")] binary_dep_depinfo: bool = (false, parse_bool, [TRACKED], "include artifacts (sysroot, crate dependencies) used during compilation in dep-info \ (default: no)"), @@ -1310,7 +1310,9 @@ options! { "emit the bc module with thin LTO info (default: yes)"), export_executable_symbols: bool = (false, parse_bool, [TRACKED], "export symbols from executables, as if they were dynamic libraries"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::fewer_names` instead of this field"))] + extra_const_ub_checks: bool = (false, parse_bool, [TRACKED], + "turns on more checks to detect const UB, which can be slow (default: no)"), + #[rustc_lint_opt_deny_field_access("use `Session::fewer_names` instead of this field")] fewer_names: Option<bool> = (None, parse_opt_bool, [TRACKED], "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) \ (default: no)"), @@ -1353,7 +1355,7 @@ options! { "control whether `#[inline]` functions are in all CGUs"), input_stats: bool = (false, parse_bool, [UNTRACKED], "gather statistics about the input (default: no)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::instrument_coverage` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::instrument_coverage` instead of this field")] instrument_coverage: Option<InstrumentCoverage> = (None, parse_instrument_coverage, [TRACKED], "instrument the generated code to support LLVM source-based code coverage \ reports (note, the compiler build config must include `profiler = true`); \ @@ -1362,7 +1364,7 @@ options! { `=except-unused-generics` `=except-unused-functions` `=off` (default)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::instrument_mcount` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::instrument_mcount` instead of this field")] instrument_mcount: bool = (false, parse_bool, [TRACKED], "insert function instrument code for mcount-based tracing (default: no)"), keep_hygiene_data: bool = (false, parse_bool, [UNTRACKED], @@ -1386,7 +1388,7 @@ options! { merge_functions: Option<MergeFunctions> = (None, parse_merge_functions, [TRACKED], "control the operation of the MergeFunctions LLVM pass, taking \ the same values as the target option of the same name"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::meta_stats` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::meta_stats` instead of this field")] meta_stats: bool = (false, parse_bool, [UNTRACKED], "gather metadata statistics (default: no)"), mir_emit_retag: bool = (false, parse_bool, [TRACKED], @@ -1398,7 +1400,7 @@ options! { disabled by other flags as usual."), mir_pretty_relative_line_numbers: bool = (false, parse_bool, [UNTRACKED], "use line numbers relative to the function in mir pretty printing"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::mir_opt_level` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::mir_opt_level` instead of this field")] mir_opt_level: Option<usize> = (None, parse_opt_number, [TRACKED], "MIR optimization level (0-4; default: 1 in non optimized builds and 2 in optimized builds)"), move_size_limit: Option<usize> = (None, parse_opt_number, [TRACKED], @@ -1465,7 +1467,7 @@ options! { See #77382 and #74551."), print_fuel: Option<String> = (None, parse_opt_string, [TRACKED], "make rustc print the total optimization fuel used by a crate"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::print_llvm_passes` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::print_llvm_passes` instead of this field")] print_llvm_passes: bool = (false, parse_bool, [UNTRACKED], "print the LLVM optimization passes being run (default: no)"), print_mono_items: Option<String> = (None, parse_opt_string, [UNTRACKED], @@ -1543,7 +1545,7 @@ options! { "exclude spans when debug-printing compiler state (default: no)"), src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED], "hash algorithm of source files in debug info (`md5`, `sha1`, or `sha256`)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::stack_protector` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::stack_protector` instead of this field")] stack_protector: StackProtector = (StackProtector::None, parse_stack_protector, [TRACKED], "control stack smash protection strategy (`rustc --print stack-protector-strategies` for details)"), strict_init_checks: bool = (false, parse_bool, [TRACKED], @@ -1564,7 +1566,7 @@ options! { symbol_mangling_version: Option<SymbolManglingVersion> = (None, parse_symbol_mangling_version, [TRACKED], "which mangling version to use for symbol names ('legacy' (default) or 'v0')"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::teach` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::teach` instead of this field")] teach: bool = (false, parse_bool, [TRACKED], "show extended diagnostic help (default: no)"), temps_dir: Option<String> = (None, parse_opt_string, [UNTRACKED], @@ -1580,7 +1582,7 @@ options! { "emit directionality isolation markers in translated diagnostics"), tune_cpu: Option<String> = (None, parse_opt_string, [TRACKED], "select processor to schedule for (`rustc --print target-cpus` for details)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::lto` instead of this field")] thinlto: Option<bool> = (None, parse_opt_bool, [TRACKED], "enable ThinLTO when possible"), thir_unsafeck: bool = (false, parse_bool, [TRACKED], @@ -1589,19 +1591,19 @@ options! { /// a sequential compiler for now. This'll likely be adjusted /// in the future. Note that -Zthreads=0 is the way to get /// the num_cpus behavior. - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::threads` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::threads` instead of this field")] threads: usize = (1, parse_threads, [UNTRACKED], "use a thread pool with N threads"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::time_passes` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::time_passes` instead of this field")] time: bool = (false, parse_bool, [UNTRACKED], "measure time of rustc processes (default: no)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::time_llvm_passes` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::time_llvm_passes` instead of this field")] time_llvm_passes: bool = (false, parse_bool, [UNTRACKED], "measure time of each LLVM pass (default: no)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::time_passes` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::time_passes` instead of this field")] time_passes: bool = (false, parse_bool, [UNTRACKED], "measure time of each rustc pass (default: no)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::tls_model` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::tls_model` instead of this field")] tls_model: Option<TlsModel> = (None, parse_tls_model, [TRACKED], "choose the TLS model to use (`rustc --print tls-models` for details)"), trace_macros: bool = (false, parse_bool, [UNTRACKED], @@ -1636,17 +1638,17 @@ options! { "enable unsound and buggy MIR optimizations (default: no)"), /// This name is kind of confusing: Most unstable options enable something themselves, while /// this just allows "normal" options to be feature-gated. - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::unstable_options` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::unstable_options` instead of this field")] unstable_options: bool = (false, parse_bool, [UNTRACKED], "adds unstable command line options to rustc interface (default: no)"), use_ctors_section: Option<bool> = (None, parse_opt_bool, [TRACKED], "use legacy .ctors section for initializers rather than .init_array"), validate_mir: bool = (false, parse_bool, [UNTRACKED], "validate MIR after each transformation"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::verbose` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::verbose` instead of this field")] verbose: bool = (false, parse_bool, [UNTRACKED], "in general, enable more debug printouts (default: no)"), - #[cfg_attr(not(bootstrap), rustc_lint_opt_deny_field_access("use `Session::verify_llvm_ir` instead of this field"))] + #[rustc_lint_opt_deny_field_access("use `Session::verify_llvm_ir` instead of this field")] verify_llvm_ir: bool = (false, parse_bool, [TRACKED], "verify LLVM IR (default: no)"), virtual_function_elimination: bool = (false, parse_bool, [TRACKED], diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index 9669287b3f3..80de451276c 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -638,7 +638,7 @@ impl Session { let found_positive = requested_features.clone().any(|r| r == "+crt-static"); // JUSTIFICATION: necessary use of crate_types directly (see FIXME below) - #[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] + #[allow(rustc::bad_opt_access)] if found_positive || found_negative { found_positive } else if crate_type == Some(CrateType::ProcMacro) @@ -894,7 +894,7 @@ impl Session { } // JUSTIFICATION: defn of the suggested wrapper fns -#[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] +#[allow(rustc::bad_opt_access)] impl Session { pub fn verbose(&self) -> bool { self.opts.unstable_opts.verbose @@ -1174,7 +1174,7 @@ impl Session { } // JUSTIFICATION: part of session construction -#[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] +#[allow(rustc::bad_opt_access)] fn default_emitter( sopts: &config::Options, registry: rustc_errors::registry::Registry, @@ -1260,7 +1260,7 @@ pub enum DiagnosticOutput { } // JUSTIFICATION: literally session construction -#[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] +#[allow(rustc::bad_opt_access)] pub fn build_session( sopts: config::Options, local_crate_source_file: Option<PathBuf>, @@ -1437,7 +1437,7 @@ pub fn build_session( /// If it is useful to have a Session available already for validating a commandline argument, you /// can do so here. // JUSTIFICATION: needs to access args to validate them -#[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] +#[allow(rustc::bad_opt_access)] fn validate_commandline_args_with_session_available(sess: &Session) { // Since we don't know if code in an rlib will be linked to statically or // dynamically downstream, rustc generates `__imp_` symbols that help linkers diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs index c33629192cb..9c252fcfe1c 100644 --- a/compiler/rustc_trait_selection/src/lib.rs +++ b/compiler/rustc_trait_selection/src/lib.rs @@ -17,7 +17,6 @@ #![feature(drain_filter)] #![feature(hash_drain_filter)] #![feature(label_break_value)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(if_let_guard)] #![feature(never_type)] diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs index 8ab1aa65d3a..a54b36262b2 100644 --- a/compiler/rustc_trait_selection/src/traits/coherence.rs +++ b/compiler/rustc_trait_selection/src/traits/coherence.rs @@ -734,7 +734,21 @@ impl<'tcx> TypeVisitor<'tcx> for OrphanChecker<'tcx> { result } - // FIXME: Constants should participate in orphan checking. + /// All possible values for a constant parameter already exist + /// in the crate defining the trait, so they are always non-local[^1]. + /// + /// Because there's no way to have an impl where the first local + /// generic argument is a constant, we also don't have to fail + /// the orphan check when encountering a parameter or a generic constant. + /// + /// This means that we can completely ignore constants during the orphan check. + /// + /// See `src/test/ui/coherence/const-generics-orphan-check-ok.rs` for examples. + /// + /// [^1]: This might not hold for function pointers or trait objects in the future. + /// As these should be quite rare as const arguments and especially rare as impl + /// parameters, allowing uncovered const parameters in impls seems more useful + /// than allowing `impl<T> Trait<local_fn_ptr, T> for i32` to compile. fn visit_const(&mut self, _c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> { ControlFlow::CONTINUE } diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs index 414857f0acc..7a5e67ff74b 100644 --- a/compiler/rustc_trait_selection/src/traits/wf.rs +++ b/compiler/rustc_trait_selection/src/traits/wf.rs @@ -31,9 +31,9 @@ pub fn obligations<'a, 'tcx>( if resolved_ty == ty { // No progress, bail out to prevent "livelock". return None; + } else { + resolved_ty } - - resolved_ty } _ => ty, } @@ -41,16 +41,14 @@ pub fn obligations<'a, 'tcx>( } GenericArgKind::Const(ct) => { match ct.kind() { - ty::ConstKind::Infer(infer) => { - let resolved = infcx.shallow_resolve(infer); - if resolved == infer { + ty::ConstKind::Infer(_) => { + let resolved = infcx.shallow_resolve(ct); + if resolved == ct { // No progress. return None; + } else { + resolved } - - infcx - .tcx - .mk_const(ty::ConstS { kind: ty::ConstKind::Infer(resolved), ty: ct.ty() }) } _ => ct, } diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index 758f1ef9766..1e6cb53f3ee 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -44,7 +44,7 @@ use rustc_trait_selection::traits::error_reporting::{ }; use rustc_trait_selection::traits::wf::object_region_bounds; -use smallvec::SmallVec; +use smallvec::{smallvec, SmallVec}; use std::collections::BTreeSet; use std::slice; @@ -368,36 +368,13 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { return (tcx.intern_substs(&[]), arg_count); } - let is_object = self_ty.map_or(false, |ty| ty == self.tcx().types.trait_object_dummy_self); - struct SubstsForAstPathCtxt<'a, 'tcx> { astconv: &'a (dyn AstConv<'tcx> + 'a), def_id: DefId, generic_args: &'a GenericArgs<'a>, span: Span, - missing_type_params: Vec<Symbol>, inferred_params: Vec<Span>, infer_args: bool, - is_object: bool, - } - - impl<'tcx, 'a> SubstsForAstPathCtxt<'tcx, 'a> { - fn default_needs_object_self(&mut self, param: &ty::GenericParamDef) -> bool { - let tcx = self.astconv.tcx(); - if let GenericParamDefKind::Type { has_default, .. } = param.kind { - if self.is_object && has_default { - let default_ty = tcx.at(self.span).type_of(param.def_id); - let self_param = tcx.types.self_param; - if default_ty.walk().any(|arg| arg == self_param.into()) { - // There is no suitable inference default for a type parameter - // that references self, in an object type. - return true; - } - } - } - - false - } } impl<'a, 'tcx> CreateSubstsForGenericArgsCtxt<'a, 'tcx> for SubstsForAstPathCtxt<'a, 'tcx> { @@ -500,41 +477,23 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { GenericParamDefKind::Type { has_default, .. } => { if !infer_args && has_default { // No type parameter provided, but a default exists. - - // If we are converting an object type, then the - // `Self` parameter is unknown. However, some of the - // other type parameters may reference `Self` in their - // defaults. This will lead to an ICE if we are not - // careful! - if self.default_needs_object_self(param) { - self.missing_type_params.push(param.name); - tcx.ty_error().into() - } else { - // This is a default type parameter. - let substs = substs.unwrap(); - if substs.iter().any(|arg| match arg.unpack() { - GenericArgKind::Type(ty) => ty.references_error(), - _ => false, - }) { - // Avoid ICE #86756 when type error recovery goes awry. - return tcx.ty_error().into(); - } - self.astconv - .normalize_ty( - self.span, - EarlyBinder(tcx.at(self.span).type_of(param.def_id)) - .subst(tcx, substs), - ) - .into() + let substs = substs.unwrap(); + if substs.iter().any(|arg| match arg.unpack() { + GenericArgKind::Type(ty) => ty.references_error(), + _ => false, + }) { + // Avoid ICE #86756 when type error recovery goes awry. + return tcx.ty_error().into(); } + self.astconv + .normalize_ty( + self.span, + EarlyBinder(tcx.at(self.span).type_of(param.def_id)) + .subst(tcx, substs), + ) + .into() } else if infer_args { - // No type parameters were provided, we can infer all. - let param = if !self.default_needs_object_self(param) { - Some(param) - } else { - None - }; - self.astconv.ty_infer(param, self.span).into() + self.astconv.ty_infer(Some(param), self.span).into() } else { // We've already errored above about the mismatch. tcx.ty_error().into() @@ -564,10 +523,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { def_id, span, generic_args, - missing_type_params: vec![], inferred_params: vec![], infer_args, - is_object, }; let substs = Self::create_substs_for_generic_args( tcx, @@ -579,13 +536,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { &mut substs_ctx, ); - self.complain_about_missing_type_params( - substs_ctx.missing_type_params, - def_id, - span, - generic_args.args.is_empty(), - ); - debug!( "create_substs_for_ast_path(generic_params={:?}, self_ty={:?}) -> {:?}", generics, self_ty, substs @@ -1490,23 +1440,71 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { // Erase the `dummy_self` (`trait_object_dummy_self`) used above. let existential_trait_refs = regular_traits.iter().map(|i| { i.trait_ref().map_bound(|trait_ref: ty::TraitRef<'tcx>| { - if trait_ref.self_ty() != dummy_self { - // FIXME: There appears to be a missing filter on top of `expand_trait_aliases`, - // which picks up non-supertraits where clauses - but also, the object safety - // completely ignores trait aliases, which could be object safety hazards. We - // `delay_span_bug` here to avoid an ICE in stable even when the feature is - // disabled. (#66420) - tcx.sess.delay_span_bug( - DUMMY_SP, - &format!( - "trait_ref_to_existential called on {:?} with non-dummy Self", - trait_ref, - ), + assert_eq!(trait_ref.self_ty(), dummy_self); + + // Verify that `dummy_self` did not leak inside default type parameters. This + // could not be done at path creation, since we need to see through trait aliases. + let mut missing_type_params = vec![]; + let mut references_self = false; + let generics = tcx.generics_of(trait_ref.def_id); + let substs: Vec<_> = trait_ref + .substs + .iter() + .enumerate() + .skip(1) // Remove `Self` for `ExistentialPredicate`. + .map(|(index, arg)| { + if let ty::GenericArgKind::Type(ty) = arg.unpack() { + debug!(?ty); + if ty == dummy_self { + let param = &generics.params[index]; + missing_type_params.push(param.name); + tcx.ty_error().into() + } else if ty.walk().any(|arg| arg == dummy_self.into()) { + references_self = true; + tcx.ty_error().into() + } else { + arg + } + } else { + arg + } + }) + .collect(); + let substs = tcx.intern_substs(&substs[..]); + + let span = i.bottom().1; + let empty_generic_args = trait_bounds.iter().any(|hir_bound| { + hir_bound.trait_ref.path.res == Res::Def(DefKind::Trait, trait_ref.def_id) + && hir_bound.span.contains(span) + }); + self.complain_about_missing_type_params( + missing_type_params, + trait_ref.def_id, + span, + empty_generic_args, + ); + + if references_self { + let def_id = i.bottom().0.def_id(); + let mut err = struct_span_err!( + tcx.sess, + i.bottom().1, + E0038, + "the {} `{}` cannot be made into an object", + tcx.def_kind(def_id).descr(def_id), + tcx.item_name(def_id), + ); + err.note( + rustc_middle::traits::ObjectSafetyViolation::SupertraitSelf(smallvec![]) + .error_msg(), ); + err.emit(); } - ty::ExistentialTraitRef::erase_self_ty(tcx, trait_ref) + + ty::ExistentialTraitRef { def_id: trait_ref.def_id, substs } }) }); + let existential_projections = bounds.projection_bounds.iter().map(|(bound, _)| { bound.map_bound(|b| { if b.projection_ty.self_ty() != dummy_self { diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs index 1d1f755947f..a7df5320296 100644 --- a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs +++ b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs @@ -440,7 +440,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { call_expr: &hir::Expr<'tcx>, ) { // Next, let's construct the error - let (error_span, full_call_span, ctor_of) = match &call_expr.kind { + let (error_span, full_call_span, ctor_of, is_method) = match &call_expr.kind { hir::ExprKind::Call( hir::Expr { hir_id, span, kind: hir::ExprKind::Path(qpath), .. }, _, @@ -448,12 +448,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let Res::Def(DefKind::Ctor(of, _), _) = self.typeck_results.borrow().qpath_res(qpath, *hir_id) { - (call_span, *span, Some(of)) + (call_span, *span, Some(of), false) } else { - (call_span, *span, None) + (call_span, *span, None, false) } } - hir::ExprKind::Call(hir::Expr { span, .. }, _) => (call_span, *span, None), + hir::ExprKind::Call(hir::Expr { span, .. }, _) => (call_span, *span, None, false), hir::ExprKind::MethodCall(path_segment, _, span) => { let ident_span = path_segment.ident.span; let ident_span = if let Some(args) = path_segment.args { @@ -461,9 +461,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } else { ident_span }; - ( - *span, ident_span, None, // methods are never ctors - ) + // methods are never ctors + (*span, ident_span, None, true) } k => span_bug!(call_span, "checking argument types on a non-call: `{:?}`", k), }; @@ -545,7 +544,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let coerced_ty = expectation.only_has_type(self).unwrap_or(formal_input_ty); let can_coerce = self.can_coerce(arg_ty, coerced_ty); if !can_coerce { - return Compatibility::Incompatible(None); + return Compatibility::Incompatible(Some(ty::error::TypeError::Sorts( + ty::error::ExpectedFound::new(true, coerced_ty, arg_ty), + ))); } // Using probe here, since we don't want this subtyping to affect inference. @@ -659,7 +660,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { Applicability::MachineApplicable, ); }; - self.label_fn_like(&mut err, fn_def_id, callee_ty); + self.label_fn_like(&mut err, fn_def_id, callee_ty, Some(mismatch_idx), is_method); err.emit(); return; } @@ -701,16 +702,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } errors.drain_filter(|error| { - let Error::Invalid(provided_idx, expected_idx, Compatibility::Incompatible(error)) = error else { return false }; + let Error::Invalid(provided_idx, expected_idx, Compatibility::Incompatible(Some(e))) = error else { return false }; let (provided_ty, provided_span) = provided_arg_tys[*provided_idx]; let (expected_ty, _) = formal_and_expected_inputs[*expected_idx]; let cause = &self.misc(provided_span); let trace = TypeTrace::types(cause, true, expected_ty, provided_ty); - if let Some(e) = error { - if !matches!(trace.cause.as_failure_code(e), FailureCode::Error0308(_)) { - self.report_and_explain_type_error(trace, e).emit(); - return true; - } + if !matches!(trace.cause.as_failure_code(e), FailureCode::Error0308(_)) { + self.report_and_explain_type_error(trace, e).emit(); + return true; } false }); @@ -749,7 +748,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { format!("arguments to this {} are incorrect", call_name), ); // Call out where the function is defined - self.label_fn_like(&mut err, fn_def_id, callee_ty); + self.label_fn_like( + &mut err, + fn_def_id, + callee_ty, + Some(expected_idx.as_usize()), + is_method, + ); err.emit(); return; } @@ -1031,7 +1036,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } // Call out where the function is defined - self.label_fn_like(&mut err, fn_def_id, callee_ty); + self.label_fn_like(&mut err, fn_def_id, callee_ty, None, is_method); // And add a suggestion block for all of the parameters let suggestion_text = match suggestion_text { @@ -1781,6 +1786,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { err: &mut Diagnostic, callable_def_id: Option<DefId>, callee_ty: Option<Ty<'tcx>>, + // A specific argument should be labeled, instead of all of them + expected_idx: Option<usize>, + is_method: bool, ) { let Some(mut def_id) = callable_def_id else { return; @@ -1881,14 +1889,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .get_if_local(def_id) .and_then(|node| node.body_id()) .into_iter() - .flat_map(|id| self.tcx.hir().body(id).params); + .flat_map(|id| self.tcx.hir().body(id).params) + .skip(if is_method { 1 } else { 0 }); - for param in params { + for (_, param) in params + .into_iter() + .enumerate() + .filter(|(idx, _)| expected_idx.map_or(true, |expected_idx| expected_idx == *idx)) + { spans.push_span_label(param.span, ""); } let def_kind = self.tcx.def_kind(def_id); err.span_note(spans, &format!("{} defined here", def_kind.descr(def_id))); + } else if let Some(hir::Node::Expr(e)) = self.tcx.hir().get_if_local(def_id) + && let hir::ExprKind::Closure(hir::Closure { body, .. }) = &e.kind + { + let param = expected_idx + .and_then(|expected_idx| self.tcx.hir().body(*body).params.get(expected_idx)); + let (kind, span) = if let Some(param) = param { + ("closure parameter", param.span) + } else { + ("closure", self.tcx.def_span(def_id)) + }; + err.span_note(span, &format!("{} defined here", kind)); } else { let def_kind = self.tcx.def_kind(def_id); err.span_note( diff --git a/compiler/rustc_typeck/src/check/writeback.rs b/compiler/rustc_typeck/src/check/writeback.rs index f549807c39c..ebf1f506183 100644 --- a/compiler/rustc_typeck/src/check/writeback.rs +++ b/compiler/rustc_typeck/src/check/writeback.rs @@ -292,6 +292,17 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> { intravisit::walk_expr(self, e); } + fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) { + match &p.kind { + hir::GenericParamKind::Lifetime { .. } => { + // Nothing to write back here + } + hir::GenericParamKind::Type { .. } | hir::GenericParamKind::Const { .. } => { + self.tcx().sess.delay_span_bug(p.span, format!("unexpected generic param: {p:?}")); + } + } + } + fn visit_block(&mut self, b: &'tcx hir::Block<'tcx>) { self.visit_node_id(b.span, b.hir_id); intravisit::walk_block(self, b); diff --git a/compiler/rustc_typeck/src/lib.rs b/compiler/rustc_typeck/src/lib.rs index 1563f3552c5..8c6fb6a7718 100644 --- a/compiler/rustc_typeck/src/lib.rs +++ b/compiler/rustc_typeck/src/lib.rs @@ -65,7 +65,6 @@ This API is completely unstable and subject to change. #![feature(is_sorted)] #![feature(iter_intersperse)] #![feature(label_break_value)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(min_specialization)] #![feature(never_type)] diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs index cc8da7bccff..80b067812ba 100644 --- a/library/alloc/src/alloc.rs +++ b/library/alloc/src/alloc.rs @@ -30,13 +30,13 @@ extern "Rust" { #[rustc_allocator] #[rustc_allocator_nounwind] fn __rust_alloc(size: usize, align: usize) -> *mut u8; - #[cfg_attr(not(bootstrap), rustc_deallocator)] + #[rustc_deallocator] #[rustc_allocator_nounwind] fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize); - #[cfg_attr(not(bootstrap), rustc_reallocator)] + #[rustc_reallocator] #[rustc_allocator_nounwind] fn __rust_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8; - #[cfg_attr(not(bootstrap), rustc_allocator_zeroed)] + #[rustc_allocator_zeroed] #[rustc_allocator_nounwind] fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8; } diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs index 887246c6001..6756eecd0e0 100644 --- a/library/core/src/alloc/global.rs +++ b/library/core/src/alloc/global.rs @@ -74,7 +74,7 @@ use crate::ptr; /// { /// return null_mut(); /// }; -/// (self.arena.get() as *mut u8).add(allocated) +/// self.arena.get().cast::<u8>().add(allocated) /// } /// unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {} /// } diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs index 372141e0933..9d3e9abf557 100644 --- a/library/core/src/fmt/mod.rs +++ b/library/core/src/fmt/mod.rs @@ -119,6 +119,10 @@ pub trait Write { /// /// This function will return an instance of [`Error`] on error. /// + /// The purpose of std::fmt::Error is to abort the formatting operation when the underlying + /// destination encounters some error preventing it from accepting more text; it should + /// generally be propagated rather than handled, at least when implementing formatting traits. + /// /// # Examples /// /// ``` @@ -2562,7 +2566,7 @@ macro_rules! tuple { macro_rules! maybe_tuple_doc { ($a:ident @ #[$meta:meta] $item:item) => { - #[cfg_attr(not(bootstrap), doc(fake_variadic))] + #[doc(fake_variadic)] #[doc = "This trait is implemented for tuples up to twelve items long."] #[$meta] $item diff --git a/library/core/src/hash/mod.rs b/library/core/src/hash/mod.rs index 5974562aced..aa13435e680 100644 --- a/library/core/src/hash/mod.rs +++ b/library/core/src/hash/mod.rs @@ -900,7 +900,7 @@ mod impls { macro_rules! maybe_tuple_doc { ($a:ident @ #[$meta:meta] $item:item) => { - #[cfg_attr(not(bootstrap), doc(fake_variadic))] + #[doc(fake_variadic)] #[doc = "This trait is implemented for tuples up to twelve items long."] #[$meta] $item diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index 2d44feb15f8..15467e0191d 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -63,7 +63,7 @@ use crate::mem; use crate::sync::atomic::{self, AtomicBool, AtomicI32, AtomicIsize, AtomicU32, Ordering}; #[stable(feature = "drop_in_place", since = "1.8.0")] -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[deprecated(note = "no longer an intrinsic - use `ptr::drop_in_place` directly", since = "1.52.0")] #[inline] pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) { @@ -71,214 +71,6 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) { unsafe { crate::ptr::drop_in_place(to_drop) } } -// These have been renamed. -#[cfg(bootstrap)] -extern "rust-intrinsic" { - pub fn atomic_cxchg<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_acq<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_rel<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_acqrel<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_relaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_failrelaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_failacq<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_acq_failrelaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchg_acqrel_failrelaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_acq<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_rel<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_acqrel<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_relaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_failrelaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_failacq<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_acq_failrelaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_cxchgweak_acqrel_failrelaxed<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool); - pub fn atomic_load<T: Copy>(src: *const T) -> T; - pub fn atomic_load_acq<T: Copy>(src: *const T) -> T; - pub fn atomic_load_relaxed<T: Copy>(src: *const T) -> T; - pub fn atomic_load_unordered<T: Copy>(src: *const T) -> T; - pub fn atomic_store<T: Copy>(dst: *mut T, val: T); - pub fn atomic_store_rel<T: Copy>(dst: *mut T, val: T); - pub fn atomic_store_relaxed<T: Copy>(dst: *mut T, val: T); - pub fn atomic_store_unordered<T: Copy>(dst: *mut T, val: T); - pub fn atomic_xchg<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xchg_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xchg_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xchg_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xchg_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xadd<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xadd_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xadd_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xadd_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xadd_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xsub<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xsub_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xsub_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xsub_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xsub_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_and<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_and_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_and_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_and_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_and_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_nand<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_nand_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_nand_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_nand_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_nand_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_or<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_or_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_or_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_or_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_or_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xor<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xor_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xor_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xor_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_xor_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_max<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_max_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_max_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_max_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_max_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_min<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_min_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_min_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_min_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_min_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umin<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umin_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umin_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umin_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umin_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umax<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umax_acq<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umax_rel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umax_acqrel<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_umax_relaxed<T: Copy>(dst: *mut T, src: T) -> T; - pub fn atomic_fence(); - pub fn atomic_fence_acq(); - pub fn atomic_fence_rel(); - pub fn atomic_fence_acqrel(); - pub fn atomic_singlethreadfence(); - pub fn atomic_singlethreadfence_acq(); - pub fn atomic_singlethreadfence_rel(); - pub fn atomic_singlethreadfence_acqrel(); -} - -// These have been renamed. -#[cfg(bootstrap)] -mod atomics { - pub use super::atomic_cxchg as atomic_cxchg_seqcst_seqcst; - pub use super::atomic_cxchg_acq as atomic_cxchg_acquire_acquire; - pub use super::atomic_cxchg_acq_failrelaxed as atomic_cxchg_acquire_relaxed; - pub use super::atomic_cxchg_acqrel as atomic_cxchg_acqrel_acquire; - pub use super::atomic_cxchg_acqrel_failrelaxed as atomic_cxchg_acqrel_relaxed; - pub use super::atomic_cxchg_failacq as atomic_cxchg_seqcst_acquire; - pub use super::atomic_cxchg_failrelaxed as atomic_cxchg_seqcst_relaxed; - pub use super::atomic_cxchg_rel as atomic_cxchg_release_relaxed; - pub use super::atomic_cxchg_relaxed as atomic_cxchg_relaxed_relaxed; - - pub use super::atomic_cxchgweak as atomic_cxchgweak_seqcst_seqcst; - pub use super::atomic_cxchgweak_acq as atomic_cxchgweak_acquire_acquire; - pub use super::atomic_cxchgweak_acq_failrelaxed as atomic_cxchgweak_acquire_relaxed; - pub use super::atomic_cxchgweak_acqrel as atomic_cxchgweak_acqrel_acquire; - pub use super::atomic_cxchgweak_acqrel_failrelaxed as atomic_cxchgweak_acqrel_relaxed; - pub use super::atomic_cxchgweak_failacq as atomic_cxchgweak_seqcst_acquire; - pub use super::atomic_cxchgweak_failrelaxed as atomic_cxchgweak_seqcst_relaxed; - pub use super::atomic_cxchgweak_rel as atomic_cxchgweak_release_relaxed; - pub use super::atomic_cxchgweak_relaxed as atomic_cxchgweak_relaxed_relaxed; - - pub use super::atomic_load as atomic_load_seqcst; - pub use super::atomic_load_acq as atomic_load_acquire; - pub use super::atomic_load_relaxed; - pub use super::atomic_load_unordered; - - pub use super::atomic_store as atomic_store_seqcst; - pub use super::atomic_store_rel as atomic_store_release; - pub use super::atomic_store_relaxed; - pub use super::atomic_store_unordered; - - pub use super::atomic_xchg as atomic_xchg_seqcst; - pub use super::atomic_xchg_acq as atomic_xchg_acquire; - pub use super::atomic_xchg_acqrel; - pub use super::atomic_xchg_rel as atomic_xchg_release; - pub use super::atomic_xchg_relaxed; - - pub use super::atomic_xadd as atomic_xadd_seqcst; - pub use super::atomic_xadd_acq as atomic_xadd_acquire; - pub use super::atomic_xadd_acqrel; - pub use super::atomic_xadd_rel as atomic_xadd_release; - pub use super::atomic_xadd_relaxed; - - pub use super::atomic_xsub as atomic_xsub_seqcst; - pub use super::atomic_xsub_acq as atomic_xsub_acquire; - pub use super::atomic_xsub_acqrel; - pub use super::atomic_xsub_rel as atomic_xsub_release; - pub use super::atomic_xsub_relaxed; - - pub use super::atomic_and as atomic_and_seqcst; - pub use super::atomic_and_acq as atomic_and_acquire; - pub use super::atomic_and_acqrel; - pub use super::atomic_and_rel as atomic_and_release; - pub use super::atomic_and_relaxed; - - pub use super::atomic_nand as atomic_nand_seqcst; - pub use super::atomic_nand_acq as atomic_nand_acquire; - pub use super::atomic_nand_acqrel; - pub use super::atomic_nand_rel as atomic_nand_release; - pub use super::atomic_nand_relaxed; - - pub use super::atomic_or as atomic_or_seqcst; - pub use super::atomic_or_acq as atomic_or_acquire; - pub use super::atomic_or_acqrel; - pub use super::atomic_or_rel as atomic_or_release; - pub use super::atomic_or_relaxed; - - pub use super::atomic_xor as atomic_xor_seqcst; - pub use super::atomic_xor_acq as atomic_xor_acquire; - pub use super::atomic_xor_acqrel; - pub use super::atomic_xor_rel as atomic_xor_release; - pub use super::atomic_xor_relaxed; - - pub use super::atomic_max as atomic_max_seqcst; - pub use super::atomic_max_acq as atomic_max_acquire; - pub use super::atomic_max_acqrel; - pub use super::atomic_max_rel as atomic_max_release; - pub use super::atomic_max_relaxed; - - pub use super::atomic_min as atomic_min_seqcst; - pub use super::atomic_min_acq as atomic_min_acquire; - pub use super::atomic_min_acqrel; - pub use super::atomic_min_rel as atomic_min_release; - pub use super::atomic_min_relaxed; - - pub use super::atomic_umin as atomic_umin_seqcst; - pub use super::atomic_umin_acq as atomic_umin_acquire; - pub use super::atomic_umin_acqrel; - pub use super::atomic_umin_rel as atomic_umin_release; - pub use super::atomic_umin_relaxed; - - pub use super::atomic_umax as atomic_umax_seqcst; - pub use super::atomic_umax_acq as atomic_umax_acquire; - pub use super::atomic_umax_acqrel; - pub use super::atomic_umax_rel as atomic_umax_release; - pub use super::atomic_umax_relaxed; - - pub use super::atomic_fence as atomic_fence_seqcst; - pub use super::atomic_fence_acq as atomic_fence_acquire; - pub use super::atomic_fence_acqrel; - pub use super::atomic_fence_rel as atomic_fence_release; - - pub use super::atomic_singlethreadfence as atomic_singlethreadfence_seqcst; - pub use super::atomic_singlethreadfence_acq as atomic_singlethreadfence_acquire; - pub use super::atomic_singlethreadfence_acqrel; - pub use super::atomic_singlethreadfence_rel as atomic_singlethreadfence_release; -} - -#[cfg(bootstrap)] -pub use atomics::*; - -#[cfg(not(bootstrap))] extern "rust-intrinsic" { // N.B., these intrinsics take raw pointers because they mutate aliased // memory, which is not valid for either `&` or `&mut`. @@ -951,7 +743,6 @@ extern "rust-intrinsic" { // // These are the aliases for the old names. // To be removed when stdarch and panic_unwind have been updated. -#[cfg(not(bootstrap))] mod atomics { pub use super::atomic_cxchg_acqrel_acquire as atomic_cxchg_acqrel; pub use super::atomic_cxchg_acqrel_relaxed as atomic_cxchg_acqrel_failrelaxed; @@ -965,7 +756,6 @@ mod atomics { pub use super::atomic_store_seqcst as atomic_store; } -#[cfg(not(bootstrap))] pub use atomics::*; extern "rust-intrinsic" { @@ -1463,7 +1253,7 @@ extern "rust-intrinsic" { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - #[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] + #[rustc_allowed_through_unstable_modules] #[rustc_const_stable(feature = "const_transmute", since = "1.56.0")] #[rustc_diagnostic_item = "transmute"] pub fn transmute<T, U>(e: T) -> U; @@ -2300,12 +2090,10 @@ extern "rust-intrinsic" { /// `ptr` must point to a vtable. /// The intrinsic will return the size stored in that vtable. - #[cfg(not(bootstrap))] pub fn vtable_size(ptr: *const ()) -> usize; /// `ptr` must point to a vtable. /// The intrinsic will return the alignment stored in that vtable. - #[cfg(not(bootstrap))] pub fn vtable_align(ptr: *const ()) -> usize; } @@ -2452,7 +2240,7 @@ pub(crate) fn is_nonoverlapping<T>(src: *const T, dst: *const T, count: usize) - /// [`Vec::append`]: ../../std/vec/struct.Vec.html#method.append #[doc(alias = "memcpy")] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[inline] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces @@ -2539,7 +2327,7 @@ pub const unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: us /// ``` #[doc(alias = "memmove")] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.63.0")] #[inline] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces @@ -2607,7 +2395,7 @@ pub const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) { /// ``` #[doc(alias = "memset")] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[rustc_const_unstable(feature = "const_ptr_write", issue = "86302")] #[inline] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces diff --git a/library/core/src/iter/adapters/array_chunks.rs b/library/core/src/iter/adapters/array_chunks.rs new file mode 100644 index 00000000000..9b479a9f8ad --- /dev/null +++ b/library/core/src/iter/adapters/array_chunks.rs @@ -0,0 +1,182 @@ +use crate::array; +use crate::iter::{ByRefSized, FusedIterator, Iterator}; +use crate::ops::{ControlFlow, NeverShortCircuit, Try}; + +/// An iterator over `N` elements of the iterator at a time. +/// +/// The chunks do not overlap. If `N` does not divide the length of the +/// iterator, then the last up to `N-1` elements will be omitted. +/// +/// This `struct` is created by the [`array_chunks`][Iterator::array_chunks] +/// method on [`Iterator`]. See its documentation for more. +#[derive(Debug, Clone)] +#[must_use = "iterators are lazy and do nothing unless consumed"] +#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] +pub struct ArrayChunks<I: Iterator, const N: usize> { + iter: I, + remainder: Option<array::IntoIter<I::Item, N>>, +} + +impl<I, const N: usize> ArrayChunks<I, N> +where + I: Iterator, +{ + #[track_caller] + pub(in crate::iter) fn new(iter: I) -> Self { + assert!(N != 0, "chunk size must be non-zero"); + Self { iter, remainder: None } + } + + /// Returns an iterator over the remaining elements of the original iterator + /// that are not going to be returned by this iterator. The returned + /// iterator will yield at most `N-1` elements. + #[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] + #[inline] + pub fn into_remainder(self) -> Option<array::IntoIter<I::Item, N>> { + self.remainder + } +} + +#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] +impl<I, const N: usize> Iterator for ArrayChunks<I, N> +where + I: Iterator, +{ + type Item = [I::Item; N]; + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + self.try_for_each(ControlFlow::Break).break_value() + } + + #[inline] + fn size_hint(&self) -> (usize, Option<usize>) { + let (lower, upper) = self.iter.size_hint(); + + (lower / N, upper.map(|n| n / N)) + } + + #[inline] + fn count(self) -> usize { + self.iter.count() / N + } + + fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R + where + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try<Output = B>, + { + let mut acc = init; + loop { + match self.iter.next_chunk() { + Ok(chunk) => acc = f(acc, chunk)?, + Err(remainder) => { + // Make sure to not override `self.remainder` with an empty array + // when `next` is called after `ArrayChunks` exhaustion. + self.remainder.get_or_insert(remainder); + + break try { acc }; + } + } + } + } + + fn fold<B, F>(mut self, init: B, f: F) -> B + where + Self: Sized, + F: FnMut(B, Self::Item) -> B, + { + self.try_fold(init, NeverShortCircuit::wrap_mut_2(f)).0 + } +} + +#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] +impl<I, const N: usize> DoubleEndedIterator for ArrayChunks<I, N> +where + I: DoubleEndedIterator + ExactSizeIterator, +{ + #[inline] + fn next_back(&mut self) -> Option<Self::Item> { + self.try_rfold((), |(), x| ControlFlow::Break(x)).break_value() + } + + fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R + where + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try<Output = B>, + { + // We are iterating from the back we need to first handle the remainder. + self.next_back_remainder(); + + let mut acc = init; + let mut iter = ByRefSized(&mut self.iter).rev(); + + // NB remainder is handled by `next_back_remainder`, so + // `next_chunk` can't return `Err` with non-empty remainder + // (assuming correct `I as ExactSizeIterator` impl). + while let Ok(mut chunk) = iter.next_chunk() { + // FIXME: do not do double reverse + // (we could instead add `next_chunk_back` for example) + chunk.reverse(); + acc = f(acc, chunk)? + } + + try { acc } + } + + fn rfold<B, F>(mut self, init: B, f: F) -> B + where + Self: Sized, + F: FnMut(B, Self::Item) -> B, + { + self.try_rfold(init, NeverShortCircuit::wrap_mut_2(f)).0 + } +} + +impl<I, const N: usize> ArrayChunks<I, N> +where + I: DoubleEndedIterator + ExactSizeIterator, +{ + /// Updates `self.remainder` such that `self.iter.len` is divisible by `N`. + fn next_back_remainder(&mut self) { + // Make sure to not override `self.remainder` with an empty array + // when `next_back` is called after `ArrayChunks` exhaustion. + if self.remainder.is_some() { + return; + } + + // We use the `ExactSizeIterator` implementation of the underlying + // iterator to know how many remaining elements there are. + let rem = self.iter.len() % N; + + // Take the last `rem` elements out of `self.iter`. + let mut remainder = + // SAFETY: `unwrap_err` always succeeds because x % N < N for all x. + unsafe { self.iter.by_ref().rev().take(rem).next_chunk().unwrap_err_unchecked() }; + + // We used `.rev()` above, so we need to re-reverse the reminder + remainder.as_mut_slice().reverse(); + self.remainder = Some(remainder); + } +} + +#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] +impl<I, const N: usize> FusedIterator for ArrayChunks<I, N> where I: FusedIterator {} + +#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] +impl<I, const N: usize> ExactSizeIterator for ArrayChunks<I, N> +where + I: ExactSizeIterator, +{ + #[inline] + fn len(&self) -> usize { + self.iter.len() / N + } + + #[inline] + fn is_empty(&self) -> bool { + self.iter.len() < N + } +} diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs index 916a26e2424..bf4fabad32a 100644 --- a/library/core/src/iter/adapters/mod.rs +++ b/library/core/src/iter/adapters/mod.rs @@ -1,6 +1,7 @@ use crate::iter::{InPlaceIterable, Iterator}; use crate::ops::{ChangeOutputType, ControlFlow, FromResidual, NeverShortCircuit, Residual, Try}; +mod array_chunks; mod by_ref_sized; mod chain; mod cloned; @@ -32,6 +33,9 @@ pub use self::{ scan::Scan, skip::Skip, skip_while::SkipWhile, take::Take, take_while::TakeWhile, zip::Zip, }; +#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] +pub use self::array_chunks::ArrayChunks; + #[unstable(feature = "std_internals", issue = "none")] pub use self::by_ref_sized::ByRefSized; diff --git a/library/core/src/iter/mod.rs b/library/core/src/iter/mod.rs index d5c6aed5b6c..9514466bd0c 100644 --- a/library/core/src/iter/mod.rs +++ b/library/core/src/iter/mod.rs @@ -398,6 +398,8 @@ pub use self::traits::{ #[stable(feature = "iter_zip", since = "1.59.0")] pub use self::adapters::zip; +#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] +pub use self::adapters::ArrayChunks; #[unstable(feature = "std_internals", issue = "none")] pub use self::adapters::ByRefSized; #[stable(feature = "iter_cloned", since = "1.1.0")] diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs index 275412b57b5..b2d08f4b0f6 100644 --- a/library/core/src/iter/traits/iterator.rs +++ b/library/core/src/iter/traits/iterator.rs @@ -5,7 +5,7 @@ use crate::ops::{ChangeOutputType, ControlFlow, FromResidual, Residual, Try}; use super::super::try_process; use super::super::ByRefSized; use super::super::TrustedRandomAccessNoCoerce; -use super::super::{Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, Fuse}; +use super::super::{ArrayChunks, Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, Fuse}; use super::super::{FlatMap, Flatten}; use super::super::{FromIterator, Intersperse, IntersperseWith, Product, Sum, Zip}; use super::super::{ @@ -3316,6 +3316,49 @@ pub trait Iterator { Cycle::new(self) } + /// Returns an iterator over `N` elements of the iterator at a time. + /// + /// The chunks do not overlap. If `N` does not divide the length of the + /// iterator, then the last up to `N-1` elements will be omitted and can be + /// retrieved from the [`.into_remainder()`][ArrayChunks::into_remainder] + /// function of the iterator. + /// + /// # Panics + /// + /// Panics if `N` is 0. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(iter_array_chunks)] + /// + /// let mut iter = "lorem".chars().array_chunks(); + /// assert_eq!(iter.next(), Some(['l', 'o'])); + /// assert_eq!(iter.next(), Some(['r', 'e'])); + /// assert_eq!(iter.next(), None); + /// assert_eq!(iter.into_remainder().unwrap().as_slice(), &['m']); + /// ``` + /// + /// ``` + /// #![feature(iter_array_chunks)] + /// + /// let data = [1, 1, 2, -2, 6, 0, 3, 1]; + /// // ^-----^ ^------^ + /// for [x, y, z] in data.iter().array_chunks() { + /// assert_eq!(x + y + z, 4); + /// } + /// ``` + #[track_caller] + #[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")] + fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N> + where + Self: Sized, + { + ArrayChunks::new(self) + } + /// Sums the elements of an iterator. /// /// Takes each element, adds them together, and returns the result. diff --git a/library/core/src/mem/transmutability.rs b/library/core/src/mem/transmutability.rs index b59a5b89d83..b4fabedad78 100644 --- a/library/core/src/mem/transmutability.rs +++ b/library/core/src/mem/transmutability.rs @@ -4,7 +4,7 @@ /// any value of type `Self` are safely transmutable into a value of type `Dst`, in a given `Context`, /// notwithstanding whatever safety checks you have asked the compiler to [`Assume`] are satisfied. #[unstable(feature = "transmutability", issue = "99571")] -#[cfg_attr(not(bootstrap), lang = "transmute_trait")] +#[lang = "transmute_trait"] #[rustc_on_unimplemented( message = "`{Src}` cannot be safely transmuted into `{Self}` in the defining scope of `{Context}`.", label = "`{Src}` cannot be safely transmuted into `{Self}` in the defining scope of `{Context}`." diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs index b8e5461640c..1c14b9341ca 100644 --- a/library/core/src/primitive_docs.rs +++ b/library/core/src/primitive_docs.rs @@ -996,7 +996,7 @@ impl<T> (T,) {} // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on arbitrary-length tuples. impl<T: Clone> Clone for (T,) { fn clone(&self) -> Self { @@ -1007,7 +1007,7 @@ impl<T: Clone> Clone for (T,) { // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on arbitrary-length tuples. impl<T: Copy> Copy for (T,) { // empty @@ -1484,13 +1484,12 @@ mod prim_fn {} // Required to make auto trait impls render. // See src/librustdoc/passes/collect_trait_impls.rs:collect_trait_impls #[doc(hidden)] -#[cfg(not(bootstrap))] impl<Ret, T> fn(T) -> Ret {} // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on function pointers with any number of arguments. impl<Ret, T> Clone for fn(T) -> Ret { fn clone(&self) -> Self { @@ -1501,7 +1500,7 @@ impl<Ret, T> Clone for fn(T) -> Ret { // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on function pointers with any number of arguments. impl<Ret, T> Copy for fn(T) -> Ret { // empty diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs index c0f609a01b5..c25b159c533 100644 --- a/library/core/src/ptr/const_ptr.rs +++ b/library/core/src/ptr/const_ptr.rs @@ -1267,20 +1267,21 @@ impl<T: ?Sized> *const T { /// Accessing adjacent `u8` as `u16` /// /// ``` - /// # fn foo(n: usize) { - /// # use std::mem::align_of; + /// use std::mem::align_of; + /// /// # unsafe { - /// let x = [5u8, 6u8, 7u8, 8u8, 9u8]; - /// let ptr = x.as_ptr().add(n) as *const u8; + /// let x = [5_u8, 6, 7, 8, 9]; + /// let ptr = x.as_ptr(); /// let offset = ptr.align_offset(align_of::<u16>()); - /// if offset < x.len() - n - 1 { - /// let u16_ptr = ptr.add(offset) as *const u16; - /// assert_ne!(*u16_ptr, 500); + /// + /// if offset < x.len() - 1 { + /// let u16_ptr = ptr.add(offset).cast::<u16>(); + /// assert!(*u16_ptr == u16::from_ne_bytes([5, 6]) || *u16_ptr == u16::from_ne_bytes([6, 7])); /// } else { /// // while the pointer can be aligned via `offset`, it would point /// // outside the allocation /// } - /// # } } + /// # } /// ``` #[stable(feature = "align_offset", since = "1.36.0")] #[rustc_const_unstable(feature = "const_align_offset", issue = "90962")] diff --git a/library/core/src/ptr/metadata.rs b/library/core/src/ptr/metadata.rs index cd5edee0460..8865c834c88 100644 --- a/library/core/src/ptr/metadata.rs +++ b/library/core/src/ptr/metadata.rs @@ -180,7 +180,6 @@ pub struct DynMetadata<Dyn: ?Sized> { phantom: crate::marker::PhantomData<Dyn>, } -#[cfg(not(bootstrap))] extern "C" { /// Opaque type for accessing vtables. /// @@ -189,17 +188,6 @@ extern "C" { type VTable; } -/// The common prefix of all vtables. It is followed by function pointers for trait methods. -/// -/// Private implementation detail of `DynMetadata::size_of` etc. -#[repr(C)] -#[cfg(bootstrap)] -struct VTable { - drop_in_place: fn(*mut ()), - size_of: usize, - align_of: usize, -} - impl<Dyn: ?Sized> DynMetadata<Dyn> { /// Returns the size of the type associated with this vtable. #[inline] @@ -207,9 +195,6 @@ impl<Dyn: ?Sized> DynMetadata<Dyn> { // Note that "size stored in vtable" is *not* the same as "result of size_of_val_raw". // Consider a reference like `&(i32, dyn Send)`: the vtable will only store the size of the // `Send` part! - #[cfg(bootstrap)] - return self.vtable_ptr.size_of; - #[cfg(not(bootstrap))] // SAFETY: DynMetadata always contains a valid vtable pointer return unsafe { crate::intrinsics::vtable_size(self.vtable_ptr as *const VTable as *const ()) @@ -219,9 +204,6 @@ impl<Dyn: ?Sized> DynMetadata<Dyn> { /// Returns the alignment of the type associated with this vtable. #[inline] pub fn align_of(self) -> usize { - #[cfg(bootstrap)] - return self.vtable_ptr.align_of; - #[cfg(not(bootstrap))] // SAFETY: DynMetadata always contains a valid vtable pointer return unsafe { crate::intrinsics::vtable_align(self.vtable_ptr as *const VTable as *const ()) diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs index 40e28e636d8..203531f66aa 100644 --- a/library/core/src/ptr/mod.rs +++ b/library/core/src/ptr/mod.rs @@ -603,6 +603,7 @@ pub const fn invalid_mut<T>(addr: usize) -> *mut T { #[must_use] #[inline] #[unstable(feature = "strict_provenance", issue = "95228")] +#[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces pub fn from_exposed_addr<T>(addr: usize) -> *const T where T: Sized, @@ -639,6 +640,7 @@ where #[must_use] #[inline] #[unstable(feature = "strict_provenance", issue = "95228")] +#[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces pub fn from_exposed_addr_mut<T>(addr: usize) -> *mut T where T: Sized, @@ -1834,7 +1836,7 @@ macro_rules! maybe_fnptr_doc { $item }; ($a:ident @ #[$meta:meta] $item:item) => { - #[cfg_attr(not(bootstrap), doc(fake_variadic))] + #[doc(fake_variadic)] #[doc = "This trait is implemented for function pointers with up to twelve arguments."] #[$meta] $item diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs index 7059d0008c4..fff06b458c7 100644 --- a/library/core/src/ptr/mut_ptr.rs +++ b/library/core/src/ptr/mut_ptr.rs @@ -1545,20 +1545,23 @@ impl<T: ?Sized> *mut T { /// Accessing adjacent `u8` as `u16` /// /// ``` - /// # fn foo(n: usize) { - /// # use std::mem::align_of; + /// use std::mem::align_of; + /// /// # unsafe { - /// let x = [5u8, 6u8, 7u8, 8u8, 9u8]; - /// let ptr = x.as_ptr().add(n) as *const u8; + /// let mut x = [5_u8, 6, 7, 8, 9]; + /// let ptr = x.as_mut_ptr(); /// let offset = ptr.align_offset(align_of::<u16>()); - /// if offset < x.len() - n - 1 { - /// let u16_ptr = ptr.add(offset) as *const u16; - /// assert_ne!(*u16_ptr, 500); + /// + /// if offset < x.len() - 1 { + /// let u16_ptr = ptr.add(offset).cast::<u16>(); + /// *u16_ptr = 0; + /// + /// assert!(x == [0, 0, 7, 8, 9] || x == [5, 0, 0, 8, 9]); /// } else { /// // while the pointer can be aligned via `offset`, it would point /// // outside the allocation /// } - /// # } } + /// # } /// ``` #[stable(feature = "align_offset", since = "1.36.0")] #[rustc_const_unstable(feature = "const_align_offset", issue = "90962")] diff --git a/library/core/src/slice/iter.rs b/library/core/src/slice/iter.rs index f1e65930967..f43b780ec9a 100644 --- a/library/core/src/slice/iter.rs +++ b/library/core/src/slice/iter.rs @@ -92,7 +92,7 @@ impl<'a, T> Iter<'a, T> { assume(!ptr.is_null()); let end = if mem::size_of::<T>() == 0 { - (ptr as *const u8).wrapping_add(slice.len()) as *const T + ptr.wrapping_byte_add(slice.len()) } else { ptr.add(slice.len()) }; @@ -228,7 +228,7 @@ impl<'a, T> IterMut<'a, T> { assume(!ptr.is_null()); let end = if mem::size_of::<T>() == 0 { - (ptr as *mut u8).wrapping_add(slice.len()) as *mut T + ptr.wrapping_byte_add(slice.len()) } else { ptr.add(slice.len()) }; diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index e6ca6ef8267..e79d47c9f98 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -4101,7 +4101,6 @@ impl<T, const N: usize> [[T; N]] { } } -#[cfg(not(bootstrap))] #[cfg(not(test))] impl [f32] { /// Sorts the slice of floats. @@ -4131,7 +4130,6 @@ impl [f32] { } } -#[cfg(not(bootstrap))] #[cfg(not(test))] impl [f64] { /// Sorts the slice of floats. diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs index 5e2e0c4d8cc..40ca9abd6bd 100644 --- a/library/core/src/sync/atomic.rs +++ b/library/core/src/sync/atomic.rs @@ -1584,16 +1584,8 @@ impl<T> AtomicPtr<T> { #[unstable(feature = "strict_provenance_atomic_ptr", issue = "99108")] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces pub fn fetch_byte_add(&self, val: usize, order: Ordering) -> *mut T { - #[cfg(not(bootstrap))] // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_add(self.p.get(), core::ptr::invalid_mut(val), order).cast() - } - #[cfg(bootstrap)] - // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_add(self.p.get().cast::<usize>(), val, order) as *mut T - } + unsafe { atomic_add(self.p.get(), core::ptr::invalid_mut(val), order).cast() } } /// Offsets the pointer's address by subtracting `val` *bytes*, returning the @@ -1628,16 +1620,8 @@ impl<T> AtomicPtr<T> { #[unstable(feature = "strict_provenance_atomic_ptr", issue = "99108")] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces pub fn fetch_byte_sub(&self, val: usize, order: Ordering) -> *mut T { - #[cfg(not(bootstrap))] // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_sub(self.p.get(), core::ptr::invalid_mut(val), order).cast() - } - #[cfg(bootstrap)] - // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_sub(self.p.get().cast::<usize>(), val, order) as *mut T - } + unsafe { atomic_sub(self.p.get(), core::ptr::invalid_mut(val), order).cast() } } /// Performs a bitwise "or" operation on the address of the current pointer, @@ -1687,16 +1671,8 @@ impl<T> AtomicPtr<T> { #[unstable(feature = "strict_provenance_atomic_ptr", issue = "99108")] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces pub fn fetch_or(&self, val: usize, order: Ordering) -> *mut T { - #[cfg(not(bootstrap))] - // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_or(self.p.get(), core::ptr::invalid_mut(val), order).cast() - } - #[cfg(bootstrap)] // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_or(self.p.get().cast::<usize>(), val, order) as *mut T - } + unsafe { atomic_or(self.p.get(), core::ptr::invalid_mut(val), order).cast() } } /// Performs a bitwise "and" operation on the address of the current @@ -1745,16 +1721,8 @@ impl<T> AtomicPtr<T> { #[unstable(feature = "strict_provenance_atomic_ptr", issue = "99108")] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces pub fn fetch_and(&self, val: usize, order: Ordering) -> *mut T { - #[cfg(not(bootstrap))] - // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_and(self.p.get(), core::ptr::invalid_mut(val), order).cast() - } - #[cfg(bootstrap)] // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_and(self.p.get().cast::<usize>(), val, order) as *mut T - } + unsafe { atomic_and(self.p.get(), core::ptr::invalid_mut(val), order).cast() } } /// Performs a bitwise "xor" operation on the address of the current @@ -1801,16 +1769,8 @@ impl<T> AtomicPtr<T> { #[unstable(feature = "strict_provenance_atomic_ptr", issue = "99108")] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces pub fn fetch_xor(&self, val: usize, order: Ordering) -> *mut T { - #[cfg(not(bootstrap))] - // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_xor(self.p.get(), core::ptr::invalid_mut(val), order).cast() - } - #[cfg(bootstrap)] // SAFETY: data races are prevented by atomic intrinsics. - unsafe { - atomic_xor(self.p.get().cast::<usize>(), val, order) as *mut T - } + unsafe { atomic_xor(self.p.get(), core::ptr::invalid_mut(val), order).cast() } } } @@ -3073,30 +3033,22 @@ unsafe fn atomic_compare_exchange<T: Copy>( let (val, ok) = unsafe { match (success, failure) { (Relaxed, Relaxed) => intrinsics::atomic_cxchg_relaxed_relaxed(dst, old, new), - #[cfg(not(bootstrap))] (Relaxed, Acquire) => intrinsics::atomic_cxchg_relaxed_acquire(dst, old, new), - #[cfg(not(bootstrap))] (Relaxed, SeqCst) => intrinsics::atomic_cxchg_relaxed_seqcst(dst, old, new), (Acquire, Relaxed) => intrinsics::atomic_cxchg_acquire_relaxed(dst, old, new), (Acquire, Acquire) => intrinsics::atomic_cxchg_acquire_acquire(dst, old, new), - #[cfg(not(bootstrap))] (Acquire, SeqCst) => intrinsics::atomic_cxchg_acquire_seqcst(dst, old, new), (Release, Relaxed) => intrinsics::atomic_cxchg_release_relaxed(dst, old, new), - #[cfg(not(bootstrap))] (Release, Acquire) => intrinsics::atomic_cxchg_release_acquire(dst, old, new), - #[cfg(not(bootstrap))] (Release, SeqCst) => intrinsics::atomic_cxchg_release_seqcst(dst, old, new), (AcqRel, Relaxed) => intrinsics::atomic_cxchg_acqrel_relaxed(dst, old, new), (AcqRel, Acquire) => intrinsics::atomic_cxchg_acqrel_acquire(dst, old, new), - #[cfg(not(bootstrap))] (AcqRel, SeqCst) => intrinsics::atomic_cxchg_acqrel_seqcst(dst, old, new), (SeqCst, Relaxed) => intrinsics::atomic_cxchg_seqcst_relaxed(dst, old, new), (SeqCst, Acquire) => intrinsics::atomic_cxchg_seqcst_acquire(dst, old, new), (SeqCst, SeqCst) => intrinsics::atomic_cxchg_seqcst_seqcst(dst, old, new), (_, AcqRel) => panic!("there is no such thing as an acquire-release failure ordering"), (_, Release) => panic!("there is no such thing as a release failure ordering"), - #[cfg(bootstrap)] - _ => panic!("a failure ordering can't be stronger than a success ordering"), } }; if ok { Ok(val) } else { Err(val) } @@ -3116,30 +3068,22 @@ unsafe fn atomic_compare_exchange_weak<T: Copy>( let (val, ok) = unsafe { match (success, failure) { (Relaxed, Relaxed) => intrinsics::atomic_cxchgweak_relaxed_relaxed(dst, old, new), - #[cfg(not(bootstrap))] (Relaxed, Acquire) => intrinsics::atomic_cxchgweak_relaxed_acquire(dst, old, new), - #[cfg(not(bootstrap))] (Relaxed, SeqCst) => intrinsics::atomic_cxchgweak_relaxed_seqcst(dst, old, new), (Acquire, Relaxed) => intrinsics::atomic_cxchgweak_acquire_relaxed(dst, old, new), (Acquire, Acquire) => intrinsics::atomic_cxchgweak_acquire_acquire(dst, old, new), - #[cfg(not(bootstrap))] (Acquire, SeqCst) => intrinsics::atomic_cxchgweak_acquire_seqcst(dst, old, new), (Release, Relaxed) => intrinsics::atomic_cxchgweak_release_relaxed(dst, old, new), - #[cfg(not(bootstrap))] (Release, Acquire) => intrinsics::atomic_cxchgweak_release_acquire(dst, old, new), - #[cfg(not(bootstrap))] (Release, SeqCst) => intrinsics::atomic_cxchgweak_release_seqcst(dst, old, new), (AcqRel, Relaxed) => intrinsics::atomic_cxchgweak_acqrel_relaxed(dst, old, new), (AcqRel, Acquire) => intrinsics::atomic_cxchgweak_acqrel_acquire(dst, old, new), - #[cfg(not(bootstrap))] (AcqRel, SeqCst) => intrinsics::atomic_cxchgweak_acqrel_seqcst(dst, old, new), (SeqCst, Relaxed) => intrinsics::atomic_cxchgweak_seqcst_relaxed(dst, old, new), (SeqCst, Acquire) => intrinsics::atomic_cxchgweak_seqcst_acquire(dst, old, new), (SeqCst, SeqCst) => intrinsics::atomic_cxchgweak_seqcst_seqcst(dst, old, new), (_, AcqRel) => panic!("there is no such thing as an acquire-release failure ordering"), (_, Release) => panic!("there is no such thing as a release failure ordering"), - #[cfg(bootstrap)] - _ => panic!("a failure ordering can't be stronger than a success ordering"), } }; if ok { Ok(val) } else { Err(val) } diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs index d189e6400f1..aa8a2425bf4 100644 --- a/library/core/src/tuple.rs +++ b/library/core/src/tuple.rs @@ -107,7 +107,7 @@ macro_rules! tuple_impls { // Otherwise, it hides the docs entirely. macro_rules! maybe_tuple_doc { ($a:ident @ #[$meta:meta] $item:item) => { - #[cfg_attr(not(bootstrap), doc(fake_variadic))] + #[doc(fake_variadic)] #[doc = "This trait is implemented for tuples up to twelve items long."] #[$meta] $item diff --git a/library/core/tests/const_ptr.rs b/library/core/tests/const_ptr.rs index 152fed803ec..d874f08317f 100644 --- a/library/core/tests/const_ptr.rs +++ b/library/core/tests/const_ptr.rs @@ -3,7 +3,7 @@ const DATA: [u16; 2] = [u16::from_ne_bytes([0x01, 0x23]), u16::from_ne_bytes([0x const fn unaligned_ptr() -> *const u16 { // Since DATA.as_ptr() is aligned to two bytes, adding 1 byte to that produces an unaligned *const u16 - unsafe { (DATA.as_ptr() as *const u8).add(1) as *const u16 } + unsafe { DATA.as_ptr().byte_add(1) } } #[test] @@ -67,7 +67,7 @@ fn write() { const fn write_unaligned() -> [u16; 2] { let mut two_aligned = [0u16; 2]; unsafe { - let unaligned_ptr = (two_aligned.as_mut_ptr() as *mut u8).add(1) as *mut u16; + let unaligned_ptr = two_aligned.as_mut_ptr().byte_add(1); ptr::write_unaligned(unaligned_ptr, u16::from_ne_bytes([0x23, 0x45])); } two_aligned @@ -91,7 +91,7 @@ fn mut_ptr_write() { const fn write_unaligned() -> [u16; 2] { let mut two_aligned = [0u16; 2]; unsafe { - let unaligned_ptr = (two_aligned.as_mut_ptr() as *mut u8).add(1) as *mut u16; + let unaligned_ptr = two_aligned.as_mut_ptr().byte_add(1); unaligned_ptr.write_unaligned(u16::from_ne_bytes([0x23, 0x45])); } two_aligned diff --git a/library/core/tests/iter/adapters/array_chunks.rs b/library/core/tests/iter/adapters/array_chunks.rs new file mode 100644 index 00000000000..4e9d89e1e58 --- /dev/null +++ b/library/core/tests/iter/adapters/array_chunks.rs @@ -0,0 +1,179 @@ +use core::cell::Cell; +use core::iter::{self, Iterator}; + +use super::*; + +#[test] +fn test_iterator_array_chunks_infer() { + let xs = [1, 1, 2, -2, 6, 0, 3, 1]; + for [a, b, c] in xs.iter().copied().array_chunks() { + assert_eq!(a + b + c, 4); + } +} + +#[test] +fn test_iterator_array_chunks_clone_and_drop() { + let count = Cell::new(0); + let mut it = (0..5).map(|_| CountDrop::new(&count)).array_chunks::<3>(); + assert_eq!(it.by_ref().count(), 1); + assert_eq!(count.get(), 3); + let mut it2 = it.clone(); + assert_eq!(count.get(), 3); + assert_eq!(it.into_remainder().unwrap().len(), 2); + assert_eq!(count.get(), 5); + assert!(it2.next().is_none()); + assert_eq!(it2.into_remainder().unwrap().len(), 2); + assert_eq!(count.get(), 7); +} + +#[test] +fn test_iterator_array_chunks_remainder() { + let mut it = (0..11).array_chunks::<4>(); + assert_eq!(it.next(), Some([0, 1, 2, 3])); + assert_eq!(it.next(), Some([4, 5, 6, 7])); + assert_eq!(it.next(), None); + assert_eq!(it.into_remainder().unwrap().as_slice(), &[8, 9, 10]); +} + +#[test] +fn test_iterator_array_chunks_size_hint() { + let it = (0..6).array_chunks::<1>(); + assert_eq!(it.size_hint(), (6, Some(6))); + + let it = (0..6).array_chunks::<3>(); + assert_eq!(it.size_hint(), (2, Some(2))); + + let it = (0..6).array_chunks::<5>(); + assert_eq!(it.size_hint(), (1, Some(1))); + + let it = (0..6).array_chunks::<7>(); + assert_eq!(it.size_hint(), (0, Some(0))); + + let it = (1..).array_chunks::<2>(); + assert_eq!(it.size_hint(), (usize::MAX / 2, None)); + + let it = (1..).filter(|x| x % 2 != 0).array_chunks::<2>(); + assert_eq!(it.size_hint(), (0, None)); +} + +#[test] +fn test_iterator_array_chunks_count() { + let it = (0..6).array_chunks::<1>(); + assert_eq!(it.count(), 6); + + let it = (0..6).array_chunks::<3>(); + assert_eq!(it.count(), 2); + + let it = (0..6).array_chunks::<5>(); + assert_eq!(it.count(), 1); + + let it = (0..6).array_chunks::<7>(); + assert_eq!(it.count(), 0); + + let it = (0..6).filter(|x| x % 2 == 0).array_chunks::<2>(); + assert_eq!(it.count(), 1); + + let it = iter::empty::<i32>().array_chunks::<2>(); + assert_eq!(it.count(), 0); + + let it = [(); usize::MAX].iter().array_chunks::<2>(); + assert_eq!(it.count(), usize::MAX / 2); +} + +#[test] +fn test_iterator_array_chunks_next_and_next_back() { + let mut it = (0..11).array_chunks::<3>(); + assert_eq!(it.next(), Some([0, 1, 2])); + assert_eq!(it.next_back(), Some([6, 7, 8])); + assert_eq!(it.next(), Some([3, 4, 5])); + assert_eq!(it.next_back(), None); + assert_eq!(it.next(), None); + assert_eq!(it.next_back(), None); + assert_eq!(it.next(), None); + assert_eq!(it.into_remainder().unwrap().as_slice(), &[9, 10]); +} + +#[test] +fn test_iterator_array_chunks_rev_remainder() { + let mut it = (0..11).array_chunks::<4>(); + { + let mut it = it.by_ref().rev(); + assert_eq!(it.next(), Some([4, 5, 6, 7])); + assert_eq!(it.next(), Some([0, 1, 2, 3])); + assert_eq!(it.next(), None); + assert_eq!(it.next(), None); + } + assert_eq!(it.into_remainder().unwrap().as_slice(), &[8, 9, 10]); +} + +#[test] +fn test_iterator_array_chunks_try_fold() { + let count = Cell::new(0); + let mut it = (0..10).map(|_| CountDrop::new(&count)).array_chunks::<3>(); + let result: Result<_, ()> = it.by_ref().try_fold(0, |acc, _item| Ok(acc + 1)); + assert_eq!(result, Ok(3)); + assert_eq!(count.get(), 9); + drop(it); + assert_eq!(count.get(), 10); + + let count = Cell::new(0); + let mut it = (0..10).map(|_| CountDrop::new(&count)).array_chunks::<3>(); + let result = it.by_ref().try_fold(0, |acc, _item| if acc < 2 { Ok(acc + 1) } else { Err(acc) }); + assert_eq!(result, Err(2)); + assert_eq!(count.get(), 9); + drop(it); + assert_eq!(count.get(), 9); +} + +#[test] +fn test_iterator_array_chunks_fold() { + let result = (1..11).array_chunks::<3>().fold(0, |acc, [a, b, c]| { + assert_eq!(acc + 1, a); + assert_eq!(acc + 2, b); + assert_eq!(acc + 3, c); + acc + 3 + }); + assert_eq!(result, 9); + + let count = Cell::new(0); + let result = + (0..10).map(|_| CountDrop::new(&count)).array_chunks::<3>().fold(0, |acc, _item| acc + 1); + assert_eq!(result, 3); + assert_eq!(count.get(), 10); +} + +#[test] +fn test_iterator_array_chunks_try_rfold() { + let count = Cell::new(0); + let mut it = (0..10).map(|_| CountDrop::new(&count)).array_chunks::<3>(); + let result: Result<_, ()> = it.try_rfold(0, |acc, _item| Ok(acc + 1)); + assert_eq!(result, Ok(3)); + assert_eq!(count.get(), 9); + drop(it); + assert_eq!(count.get(), 10); + + let count = Cell::new(0); + let mut it = (0..10).map(|_| CountDrop::new(&count)).array_chunks::<3>(); + let result = it.try_rfold(0, |acc, _item| if acc < 2 { Ok(acc + 1) } else { Err(acc) }); + assert_eq!(result, Err(2)); + assert_eq!(count.get(), 9); + drop(it); + assert_eq!(count.get(), 10); +} + +#[test] +fn test_iterator_array_chunks_rfold() { + let result = (1..11).array_chunks::<3>().rfold(0, |acc, [a, b, c]| { + assert_eq!(10 - (acc + 1), c); + assert_eq!(10 - (acc + 2), b); + assert_eq!(10 - (acc + 3), a); + acc + 3 + }); + assert_eq!(result, 9); + + let count = Cell::new(0); + let result = + (0..10).map(|_| CountDrop::new(&count)).array_chunks::<3>().rfold(0, |acc, _item| acc + 1); + assert_eq!(result, 3); + assert_eq!(count.get(), 10); +} diff --git a/library/core/tests/iter/adapters/mod.rs b/library/core/tests/iter/adapters/mod.rs index 567d9fe49ca..96539c0c394 100644 --- a/library/core/tests/iter/adapters/mod.rs +++ b/library/core/tests/iter/adapters/mod.rs @@ -1,3 +1,4 @@ +mod array_chunks; mod chain; mod cloned; mod copied; @@ -183,3 +184,25 @@ impl Clone for CountClone { ret } } + +#[derive(Debug, Clone)] +struct CountDrop<'a> { + dropped: bool, + count: &'a Cell<usize>, +} + +impl<'a> CountDrop<'a> { + pub fn new(count: &'a Cell<usize>) -> Self { + Self { dropped: false, count } + } +} + +impl Drop for CountDrop<'_> { + fn drop(&mut self) { + if self.dropped { + panic!("double drop"); + } + self.dropped = true; + self.count.set(self.count.get() + 1); + } +} diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index db94368f6e0..09f1500f564 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -14,6 +14,7 @@ #![feature(const_maybe_uninit_assume_init_read)] #![feature(const_nonnull_new)] #![feature(const_num_from_num)] +#![feature(const_pointer_byte_offsets)] #![feature(const_ptr_as_ref)] #![feature(const_ptr_read)] #![feature(const_ptr_write)] @@ -61,6 +62,7 @@ #![feature(slice_partition_dedup)] #![feature(int_log)] #![feature(iter_advance_by)] +#![feature(iter_array_chunks)] #![feature(iter_collect_into)] #![feature(iter_partition_in_place)] #![feature(iter_intersperse)] @@ -74,6 +76,7 @@ #![feature(never_type)] #![feature(unwrap_infallible)] #![feature(result_into_ok_or_err)] +#![feature(pointer_byte_offsets)] #![feature(portable_simd)] #![feature(ptr_metadata)] #![feature(once_cell)] diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index ebe0ccbdc0b..475a1d9fd99 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -211,7 +211,7 @@ // Tell the compiler to link to either panic_abort or panic_unwind #![needs_panic_runtime] // Ensure that std can be linked against panic_abort despite compiled with `-C panic=unwind` -#![cfg_attr(not(bootstrap), deny(ffi_unwind_calls))] +#![deny(ffi_unwind_calls)] // std may use features in a platform-specific way #![allow(unused_features)] #![cfg_attr(test, feature(internal_output_capture, print_internals, update_panic_count, rt))] @@ -243,7 +243,6 @@ #![feature(intra_doc_pointers)] #![feature(label_break_value)] #![feature(lang_items)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(linkage)] #![feature(link_cfg)] diff --git a/library/std/src/os/fd/raw.rs b/library/std/src/os/fd/raw.rs index 081915ed148..1b3d110426f 100644 --- a/library/std/src/os/fd/raw.rs +++ b/library/std/src/os/fd/raw.rs @@ -14,7 +14,7 @@ use crate::os::wasi::io::OwnedFd; use crate::sys_common::{AsInner, IntoInner}; /// Raw file descriptors. -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[stable(feature = "rust1", since = "1.0.0")] pub type RawFd = raw::c_int; @@ -23,7 +23,7 @@ pub type RawFd = raw::c_int; /// This is only available on unix and WASI platforms and must be imported in /// order to call the method. Windows platforms have a corresponding /// `AsRawHandle` and `AsRawSocket` set of traits. -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[stable(feature = "rust1", since = "1.0.0")] pub trait AsRawFd { /// Extracts the raw file descriptor. @@ -59,7 +59,7 @@ pub trait AsRawFd { /// A trait to express the ability to construct an object from a raw file /// descriptor. -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[stable(feature = "from_raw_os", since = "1.1.0")] pub trait FromRawFd { /// Constructs a new instance of `Self` from the given raw file @@ -103,7 +103,7 @@ pub trait FromRawFd { /// A trait to express the ability to consume an object and acquire ownership of /// its raw file descriptor. -#[cfg_attr(not(bootstrap), rustc_allowed_through_unstable_modules)] +#[rustc_allowed_through_unstable_modules] #[stable(feature = "into_raw_os", since = "1.4.0")] pub trait IntoRawFd { /// Consumes this object, returning the raw underlying file descriptor. diff --git a/library/std/src/primitive_docs.rs b/library/std/src/primitive_docs.rs index b8e5461640c..1c14b9341ca 100644 --- a/library/std/src/primitive_docs.rs +++ b/library/std/src/primitive_docs.rs @@ -996,7 +996,7 @@ impl<T> (T,) {} // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on arbitrary-length tuples. impl<T: Clone> Clone for (T,) { fn clone(&self) -> Self { @@ -1007,7 +1007,7 @@ impl<T: Clone> Clone for (T,) { // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on arbitrary-length tuples. impl<T: Copy> Copy for (T,) { // empty @@ -1484,13 +1484,12 @@ mod prim_fn {} // Required to make auto trait impls render. // See src/librustdoc/passes/collect_trait_impls.rs:collect_trait_impls #[doc(hidden)] -#[cfg(not(bootstrap))] impl<Ret, T> fn(T) -> Ret {} // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on function pointers with any number of arguments. impl<Ret, T> Clone for fn(T) -> Ret { fn clone(&self) -> Self { @@ -1501,7 +1500,7 @@ impl<Ret, T> Clone for fn(T) -> Ret { // Fake impl that's only really used for docs. #[cfg(doc)] #[stable(feature = "rust1", since = "1.0.0")] -#[cfg_attr(not(bootstrap), doc(fake_variadic))] +#[doc(fake_variadic)] /// This trait is implemented on function pointers with any number of arguments. impl<Ret, T> Copy for fn(T) -> Ret { // empty diff --git a/library/std/src/sys/sgx/abi/usercalls/alloc.rs b/library/std/src/sys/sgx/abi/usercalls/alloc.rs index ea24fedd0eb..66fa1efbf10 100644 --- a/library/std/src/sys/sgx/abi/usercalls/alloc.rs +++ b/library/std/src/sys/sgx/abi/usercalls/alloc.rs @@ -115,7 +115,7 @@ pub unsafe trait UserSafe { /// * the pointer is null. /// * the pointed-to range is not in user memory. unsafe fn check_ptr(ptr: *const Self) { - let is_aligned = |p| -> bool { 0 == (p as usize) & (Self::align_of() - 1) }; + let is_aligned = |p: *const u8| -> bool { 0 == p.addr() & (Self::align_of() - 1) }; assert!(is_aligned(ptr as *const u8)); assert!(is_user_range(ptr as _, mem::size_of_val(unsafe { &*ptr }))); diff --git a/library/std/src/sys/unsupported/alloc.rs b/library/std/src/sys/unsupported/alloc.rs index 8d5d0a2f5cc..d715ae45401 100644 --- a/library/std/src/sys/unsupported/alloc.rs +++ b/library/std/src/sys/unsupported/alloc.rs @@ -1,15 +1,16 @@ use crate::alloc::{GlobalAlloc, Layout, System}; +use crate::ptr::null_mut; #[stable(feature = "alloc_system_type", since = "1.28.0")] unsafe impl GlobalAlloc for System { #[inline] unsafe fn alloc(&self, _layout: Layout) -> *mut u8 { - 0 as *mut u8 + null_mut() } #[inline] unsafe fn alloc_zeroed(&self, _layout: Layout) -> *mut u8 { - 0 as *mut u8 + null_mut() } #[inline] @@ -17,6 +18,6 @@ unsafe impl GlobalAlloc for System { #[inline] unsafe fn realloc(&self, _ptr: *mut u8, _layout: Layout, _new_size: usize) -> *mut u8 { - 0 as *mut u8 + null_mut() } } diff --git a/library/std/src/sys_common/thread_local_key/tests.rs b/library/std/src/sys_common/thread_local_key/tests.rs index 968738a4180..6f32b858f09 100644 --- a/library/std/src/sys_common/thread_local_key/tests.rs +++ b/library/std/src/sys_common/thread_local_key/tests.rs @@ -1,4 +1,5 @@ use super::{Key, StaticKey}; +use core::ptr; fn assert_sync<T: Sync>() {} fn assert_send<T: Send>() {} @@ -12,8 +13,8 @@ fn smoke() { let k2 = Key::new(None); assert!(k1.get().is_null()); assert!(k2.get().is_null()); - k1.set(1 as *mut _); - k2.set(2 as *mut _); + k1.set(ptr::invalid_mut(1)); + k2.set(ptr::invalid_mut(2)); assert_eq!(k1.get() as usize, 1); assert_eq!(k2.get() as usize, 2); } @@ -26,8 +27,8 @@ fn statik() { unsafe { assert!(K1.get().is_null()); assert!(K2.get().is_null()); - K1.set(1 as *mut _); - K2.set(2 as *mut _); + K1.set(ptr::invalid_mut(1)); + K2.set(ptr::invalid_mut(2)); assert_eq!(K1.get() as usize, 1); assert_eq!(K2.get() as usize, 2); } diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs index 44c8a50fd86..479669647c1 100644 --- a/library/std/src/thread/mod.rs +++ b/library/std/src/thread/mod.rs @@ -170,7 +170,6 @@ use crate::ptr::addr_of_mut; use crate::str; use crate::sync::Arc; use crate::sys::thread as imp; -use crate::sys_common::mutex; use crate::sys_common::thread; use crate::sys_common::thread_info; use crate::sys_common::thread_parker::Parker; @@ -1033,24 +1032,48 @@ pub struct ThreadId(NonZeroU64); impl ThreadId { // Generate a new unique thread ID. fn new() -> ThreadId { - // It is UB to attempt to acquire this mutex reentrantly! - static GUARD: mutex::StaticMutex = mutex::StaticMutex::new(); - static mut COUNTER: u64 = 1; - - unsafe { - let guard = GUARD.lock(); - - // If we somehow use up all our bits, panic so that we're not - // covering up subtle bugs of IDs being reused. - if COUNTER == u64::MAX { - drop(guard); // in case the panic handler ends up calling `ThreadId::new()`, avoid reentrant lock acquire. - panic!("failed to generate unique thread ID: bitspace exhausted"); - } - - let id = COUNTER; - COUNTER += 1; + #[cold] + fn exhausted() -> ! { + panic!("failed to generate unique thread ID: bitspace exhausted") + } - ThreadId(NonZeroU64::new(id).unwrap()) + cfg_if::cfg_if! { + if #[cfg(target_has_atomic = "64")] { + use crate::sync::atomic::{AtomicU64, Ordering::Relaxed}; + + static COUNTER: AtomicU64 = AtomicU64::new(0); + + let mut last = COUNTER.load(Relaxed); + loop { + let Some(id) = last.checked_add(1) else { + exhausted(); + }; + + match COUNTER.compare_exchange_weak(last, id, Relaxed, Relaxed) { + Ok(_) => return ThreadId(NonZeroU64::new(id).unwrap()), + Err(id) => last = id, + } + } + } else { + use crate::sys_common::mutex::StaticMutex; + + // It is UB to attempt to acquire this mutex reentrantly! + static GUARD: StaticMutex = StaticMutex::new(); + static mut COUNTER: u64 = 0; + + unsafe { + let guard = GUARD.lock(); + + let Some(id) = COUNTER.checked_add(1) else { + drop(guard); // in case the panic handler ends up calling `ThreadId::new()`, avoid reentrant lock acquire. + exhausted(); + }; + + COUNTER = id; + drop(guard); + ThreadId(NonZeroU64::new(id).unwrap()) + } + } } } diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs index dd2b9d59366..c3aabb16a9b 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -658,7 +658,12 @@ impl Step for Rustc { // With LLD, we can use ICF (identical code folding) to reduce the executable size // of librustc_driver/rustc and to improve i-cache utilization. - if builder.config.use_lld { + // + // -Wl,[link options] doesn't work on MSVC. However, /OPT:ICF (technically /OPT:REF,ICF) + // is already on by default in MSVC optimized builds, which is interpreted as --icf=all: + // https://github.com/llvm/llvm-project/blob/3329cec2f79185bafd678f310fafadba2a8c76d2/lld/COFF/Driver.cpp#L1746 + // https://github.com/rust-lang/rust/blob/f22819bcce4abaff7d1246a56eec493418f9f4ee/compiler/rustc_codegen_ssa/src/back/linker.rs#L827 + if builder.config.use_lld && !compiler.host.contains("msvc") { cargo.rustflag("-Clink-args=-Wl,--icf=all"); } diff --git a/src/bootstrap/config.rs b/src/bootstrap/config.rs index 4325a237c69..c4983accc68 100644 --- a/src/bootstrap/config.rs +++ b/src/bootstrap/config.rs @@ -1445,7 +1445,11 @@ impl Config { .get(&target) .and_then(|t| t.llvm_libunwind) .or(self.llvm_libunwind_default) - .unwrap_or(LlvmLibunwind::No) + .unwrap_or(if target.contains("fuchsia") { + LlvmLibunwind::InTree + } else { + LlvmLibunwind::No + }) } pub fn submodules(&self, rust_info: &GitInfo) -> bool { diff --git a/src/bootstrap/mk/Makefile.in b/src/bootstrap/mk/Makefile.in index 1e0f7e9acf4..9a08a7be0f5 100644 --- a/src/bootstrap/mk/Makefile.in +++ b/src/bootstrap/mk/Makefile.in @@ -80,7 +80,7 @@ TESTS_IN_MINGW_2 := \ src/test/ui ci-mingw-subset-1: - $(Q)$(CFG_SRC_DIR)/x.sh test --stage 2 $(TESTS_IN_MINGW_2:%=--exclude %) + $(Q)$(CFG_SRC_DIR)/x test --stage 2 $(TESTS_IN_MINGW_2:%=--exclude %) ci-mingw-subset-2: $(Q)$(BOOTSTRAP) test --stage 2 $(TESTS_IN_MINGW_2) diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-12/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-12/Dockerfile index 8de9045c3ba..14d0ffd7500 100644 --- a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-12/Dockerfile +++ b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-12/Dockerfile @@ -44,7 +44,7 @@ ENV RUST_CONFIGURE_ARGS \ --enable-llvm-link-shared \ --set rust.thin-lto-import-instr-limit=10 -# NOTE: intentionally uses all of `x.py`, `x.sh`, and `x.ps1` to make sure they all work on Linux. +# NOTE: intentionally uses all of `x.py`, `x`, and `x.ps1` to make sure they all work on Linux. ENV SCRIPT ../x.py --stage 2 test --exclude src/tools/tidy && \ # Run the `mir-opt` tests again but this time for a 32-bit target. # This enforces that tests using `// EMIT_MIR_FOR_EACH_BIT_WIDTH` have @@ -52,7 +52,7 @@ ENV SCRIPT ../x.py --stage 2 test --exclude src/tools/tidy && \ # the PR is approved and tested for merging. # It will also detect tests lacking `// EMIT_MIR_FOR_EACH_BIT_WIDTH`, # despite having different output on 32-bit vs 64-bit targets. - ../x.sh --stage 2 test src/test/mir-opt \ + ../x --stage 2 test src/test/mir-opt \ --host='' --target=i686-unknown-linux-gnu && \ # Run the UI test suite again, but in `--pass=check` mode # diff --git a/src/doc/rustc/src/platform-support/fuchsia.md b/src/doc/rustc/src/platform-support/fuchsia.md index 61bd1b425bc..c526e4d1fa8 100644 --- a/src/doc/rustc/src/platform-support/fuchsia.md +++ b/src/doc/rustc/src/platform-support/fuchsia.md @@ -53,12 +53,6 @@ In `config.toml`, add: ```toml [build] target = ["<host_platform>", "aarch64-fuchsia", "x86_64-fuchsia"] - -[target.x86_64-fuchsia] -llvm-libunwind = "in-tree" - -[target.aarch64-fuchsia] -llvm-libunwind = "in-tree" ``` Additionally, the following environment variables must be configured (for diff --git a/src/etc/check_missing_items.py b/src/etc/check_missing_items.py index a705e238495..ce06a79a21c 100644 --- a/src/etc/check_missing_items.py +++ b/src/etc/check_missing_items.py @@ -57,7 +57,7 @@ def check_generic_bound(bound): if "trait_bound" in bound: for param in bound["trait_bound"]["generic_params"]: check_generic_param(param) - check_type(bound["trait_bound"]["trait"]) + check_path(bound["trait_bound"]["trait"]) def check_decl(decl): @@ -66,35 +66,35 @@ def check_decl(decl): if decl["output"]: check_type(decl["output"]) +def check_path(path): + args = path["args"] + if args: + if "angle_bracketed" in args: + for arg in args["angle_bracketed"]["args"]: + if "type" in arg: + check_type(arg["type"]) + elif "const" in arg: + check_type(arg["const"]["type"]) + for binding in args["angle_bracketed"]["bindings"]: + if "equality" in binding["binding"]: + term = binding["binding"]["equality"] + if "type" in term: check_type(term["type"]) + elif "const" in term: check_type(term["const"]) + elif "constraint" in binding["binding"]: + for bound in binding["binding"]["constraint"]: + check_generic_bound(bound) + elif "parenthesized" in args: + for input_ty in args["parenthesized"]["inputs"]: + check_type(input_ty) + if args["parenthesized"]["output"]: + check_type(args["parenthesized"]["output"]) + if not valid_id(path["id"]): + print("Type contained an invalid ID:", path["id"]) + sys.exit(1) def check_type(ty): if ty["kind"] == "resolved_path": - for bound in ty["inner"]["param_names"]: - check_generic_bound(bound) - args = ty["inner"]["args"] - if args: - if "angle_bracketed" in args: - for arg in args["angle_bracketed"]["args"]: - if "type" in arg: - check_type(arg["type"]) - elif "const" in arg: - check_type(arg["const"]["type"]) - for binding in args["angle_bracketed"]["bindings"]: - if "equality" in binding["binding"]: - term = binding["binding"]["equality"] - if "type" in term: check_type(term["type"]) - elif "const" in term: check_type(term["const"]) - elif "constraint" in binding["binding"]: - for bound in binding["binding"]["constraint"]: - check_generic_bound(bound) - elif "parenthesized" in args: - for input_ty in args["parenthesized"]["inputs"]: - check_type(input_ty) - if args["parenthesized"]["output"]: - check_type(args["parenthesized"]["output"]) - if not valid_id(ty["inner"]["id"]): - print("Type contained an invalid ID:", ty["inner"]["id"]) - sys.exit(1) + check_path(ty["inner"]) elif ty["kind"] == "tuple": for ty in ty["inner"]: check_type(ty) @@ -111,7 +111,7 @@ def check_type(ty): check_decl(ty["inner"]["decl"]) elif ty["kind"] == "qualified_path": check_type(ty["inner"]["self_type"]) - check_type(ty["inner"]["trait"]) + check_path(ty["inner"]["trait"]) work_list = set([crate["root"]]) @@ -174,7 +174,7 @@ while work_list: elif item["kind"] == "impl": check_generics(item["inner"]["generics"]) if item["inner"]["trait"]: - check_type(item["inner"]["trait"]) + check_path(item["inner"]["trait"]) if item["inner"]["blanket_impl"]: check_type(item["inner"]["blanket_impl"]) check_type(item["inner"]["for"]) diff --git a/src/etc/htmldocck.py b/src/etc/htmldocck.py index d02ac9d9c0a..baf95627c70 100644 --- a/src/etc/htmldocck.py +++ b/src/etc/htmldocck.py @@ -41,15 +41,15 @@ There are a number of supported commands: `PATH` is relative to the output directory. It can be given as `-` which repeats the most recently used `PATH`. -* `@has PATH PATTERN` and `@matches PATH PATTERN` checks for - the occurrence of the given pattern `PATTERN` in the specified file. +* `@hasraw PATH PATTERN` and `@matchesraw PATH PATTERN` checks + for the occurrence of the given pattern `PATTERN` in the specified file. Only one occurrence of the pattern is enough. - For `@has`, `PATTERN` is a whitespace-normalized (every consecutive + For `@hasraw`, `PATTERN` is a whitespace-normalized (every consecutive whitespace being replaced by one single space character) string. The entire file is also whitespace-normalized including newlines. - For `@matches`, `PATTERN` is a Python-supported regular expression. + For `@matchesraw`, `PATTERN` is a Python-supported regular expression. The file remains intact but the regexp is matched without the `MULTILINE` and `IGNORECASE` options. You can still use a prefix `(?m)` or `(?i)` to override them, and `\A` and `\Z` for definitely matching @@ -542,19 +542,23 @@ ERR_COUNT = 0 def check_command(c, cache): try: cerr = "" - if c.cmd == 'has' or c.cmd == 'matches': # string test - regexp = (c.cmd == 'matches') - if len(c.args) == 1 and not regexp: # @has <path> = file existence + if c.cmd in ['has', 'hasraw', 'matches', 'matchesraw']: # string test + regexp = c.cmd.startswith('matches') + + # @has <path> = file existence + if len(c.args) == 1 and not regexp and 'raw' not in c.cmd: try: cache.get_file(c.args[0]) ret = True except FailedCheck as err: cerr = str(err) ret = False - elif len(c.args) == 2: # @has/matches <path> <pat> = string test + # @hasraw/matchesraw <path> <pat> = string test + elif len(c.args) == 2 and 'raw' in c.cmd: cerr = "`PATTERN` did not match" ret = check_string(cache.get_file(c.args[0]), c.args[1], regexp) - elif len(c.args) == 3: # @has/matches <path> <pat> <match> = XML tree test + # @has/matches <path> <pat> <match> = XML tree test + elif len(c.args) == 3 and 'raw' not in c.cmd: cerr = "`XPATH PATTERN` did not match" ret = get_nb_matching_elements(cache, c, regexp, True) != 0 else: diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 6e246385489..addd6ffa11e 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1322,14 +1322,17 @@ fn clean_qpath<'tcx>(hir_ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> Type let trait_def = cx.tcx.associated_item(p.res.def_id()).container_id(cx.tcx); let trait_ = self::Path { res: Res::Def(DefKind::Trait, trait_def), - segments: trait_segments.iter().map(|x| x.clean(cx)).collect(), + segments: trait_segments.iter().map(|x| clean_path_segment(x, cx)).collect(), }; register_res(cx, trait_.res); let self_def_id = DefId::local(qself.hir_id.owner.local_def_index); let self_type = clean_ty(qself, cx); let should_show_cast = compute_should_show_cast(Some(self_def_id), &trait_, &self_type); Type::QPath { - assoc: Box::new(p.segments.last().expect("segments were empty").clean(cx)), + assoc: Box::new(clean_path_segment( + p.segments.last().expect("segments were empty"), + cx, + )), should_show_cast, self_type: Box::new(self_type), trait_, @@ -1349,7 +1352,7 @@ fn clean_qpath<'tcx>(hir_ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> Type let self_type = clean_ty(qself, cx); let should_show_cast = compute_should_show_cast(self_def_id, &trait_, &self_type); Type::QPath { - assoc: Box::new(segment.clean(cx)), + assoc: Box::new(clean_path_segment(segment, cx)), should_show_cast, self_type: Box::new(self_type), trait_, @@ -1507,7 +1510,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T if !lifetime.is_elided() { Some(clean_lifetime(*lifetime, cx)) } else { None }; DynTrait(bounds, lifetime) } - TyKind::BareFn(barefn) => BareFunction(Box::new(barefn.clean(cx))), + TyKind::BareFn(barefn) => BareFunction(Box::new(clean_bare_fn_ty(barefn, cx))), // Rustdoc handles `TyKind::Err`s by turning them into `Type::Infer`s. TyKind::Infer | TyKind::Err => Infer, TyKind::Typeof(..) => panic!("unimplemented type {:?}", ty.kind), @@ -1823,7 +1826,10 @@ fn clean_variant_data<'tcx>( } fn clean_path<'tcx>(path: &hir::Path<'tcx>, cx: &mut DocContext<'tcx>) -> Path { - Path { res: path.res, segments: path.segments.iter().map(|x| x.clean(cx)).collect() } + Path { + res: path.res, + segments: path.segments.iter().map(|x| clean_path_segment(x, cx)).collect(), + } } fn clean_generic_args<'tcx>( @@ -1861,28 +1867,30 @@ fn clean_generic_args<'tcx>( } } -impl<'tcx> Clean<'tcx, PathSegment> for hir::PathSegment<'tcx> { - fn clean(&self, cx: &mut DocContext<'tcx>) -> PathSegment { - PathSegment { name: self.ident.name, args: clean_generic_args(self.args(), cx) } - } +fn clean_path_segment<'tcx>( + path: &hir::PathSegment<'tcx>, + cx: &mut DocContext<'tcx>, +) -> PathSegment { + PathSegment { name: path.ident.name, args: clean_generic_args(path.args(), cx) } } -impl<'tcx> Clean<'tcx, BareFunctionDecl> for hir::BareFnTy<'tcx> { - fn clean(&self, cx: &mut DocContext<'tcx>) -> BareFunctionDecl { - let (generic_params, decl) = enter_impl_trait(cx, |cx| { - // NOTE: generics must be cleaned before args - let generic_params = self - .generic_params - .iter() - .filter(|p| !is_elided_lifetime(p)) - .map(|x| clean_generic_param(cx, None, x)) - .collect(); - let args = clean_args_from_types_and_names(cx, self.decl.inputs, self.param_names); - let decl = clean_fn_decl_with_args(cx, self.decl, args); - (generic_params, decl) - }); - BareFunctionDecl { unsafety: self.unsafety, abi: self.abi, decl, generic_params } - } +fn clean_bare_fn_ty<'tcx>( + bare_fn: &hir::BareFnTy<'tcx>, + cx: &mut DocContext<'tcx>, +) -> BareFunctionDecl { + let (generic_params, decl) = enter_impl_trait(cx, |cx| { + // NOTE: generics must be cleaned before args + let generic_params = bare_fn + .generic_params + .iter() + .filter(|p| !is_elided_lifetime(p)) + .map(|x| clean_generic_param(cx, None, x)) + .collect(); + let args = clean_args_from_types_and_names(cx, bare_fn.decl.inputs, bare_fn.param_names); + let decl = clean_fn_decl_with_args(cx, bare_fn.decl, args); + (generic_params, decl) + }); + BareFunctionDecl { unsafety: bare_fn.unsafety, abi: bare_fn.abi, decl, generic_params } } fn clean_maybe_renamed_item<'tcx>( diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index 91d5758077c..1a4786c9b06 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -415,29 +415,28 @@ impl Item { .unwrap_or(false) } - pub(crate) fn span(&self, tcx: TyCtxt<'_>) -> Span { + pub(crate) fn span(&self, tcx: TyCtxt<'_>) -> Option<Span> { let kind = match &*self.kind { ItemKind::StrippedItem(k) => k, _ => &*self.kind, }; match kind { - ItemKind::ModuleItem(Module { span, .. }) => *span, - ItemKind::ImplItem(box Impl { kind: ImplKind::Auto, .. }) => Span::dummy(), + ItemKind::ModuleItem(Module { span, .. }) => Some(*span), + ItemKind::ImplItem(box Impl { kind: ImplKind::Auto, .. }) => None, ItemKind::ImplItem(box Impl { kind: ImplKind::Blanket(_), .. }) => { if let ItemId::Blanket { impl_id, .. } = self.item_id { - rustc_span(impl_id, tcx) + Some(rustc_span(impl_id, tcx)) } else { panic!("blanket impl item has non-blanket ID") } } - _ => { - self.item_id.as_def_id().map(|did| rustc_span(did, tcx)).unwrap_or_else(Span::dummy) - } + _ => self.item_id.as_def_id().map(|did| rustc_span(did, tcx)), } } pub(crate) fn attr_span(&self, tcx: TyCtxt<'_>) -> rustc_span::Span { - crate::passes::span_of_attrs(&self.attrs).unwrap_or_else(|| self.span(tcx).inner()) + crate::passes::span_of_attrs(&self.attrs) + .unwrap_or_else(|| self.span(tcx).map_or(rustc_span::DUMMY_SP, |span| span.inner())) } /// Finds the `doc` attribute as a NameValue and returns the corresponding @@ -2109,14 +2108,6 @@ impl Span { self.0 } - pub(crate) fn dummy() -> Self { - Self(rustc_span::DUMMY_SP) - } - - pub(crate) fn is_dummy(&self) -> bool { - self.0.is_dummy() - } - pub(crate) fn filename(&self, sess: &Session) -> FileName { sess.source_map().span_to_filename(self.0) } diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index 5a6720a8dd9..27ccff9a276 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -163,7 +163,6 @@ enum Class { // Keywords that do pointer/reference stuff. RefKeyWord, Self_(Span), - Op, Macro(Span), MacroNonTerminal, String, @@ -187,7 +186,6 @@ impl Class { Class::KeyWord => "kw", Class::RefKeyWord => "kw-2", Class::Self_(_) => "self", - Class::Op => "op", Class::Macro(_) => "macro", Class::MacroNonTerminal => "macro-nonterminal", Class::String => "string", @@ -212,7 +210,6 @@ impl Class { | Self::Attribute | Self::KeyWord | Self::RefKeyWord - | Self::Op | Self::MacroNonTerminal | Self::String | Self::Number @@ -516,7 +513,7 @@ impl<'a> Classifier<'a> { // or a reference or pointer type. Unless, of course, it looks like // a logical and or a multiplication operator: `&&` or `* `. TokenKind::Star => match self.tokens.peek() { - Some((TokenKind::Whitespace, _)) => Class::Op, + Some((TokenKind::Whitespace, _)) => return no_highlight(sink), Some((TokenKind::Ident, "mut")) => { self.next(); sink(Highlight::Token { text: "*mut", class: Some(Class::RefKeyWord) }); @@ -532,15 +529,15 @@ impl<'a> Classifier<'a> { TokenKind::And => match self.tokens.peek() { Some((TokenKind::And, _)) => { self.next(); - sink(Highlight::Token { text: "&&", class: Some(Class::Op) }); + sink(Highlight::Token { text: "&&", class: None }); return; } Some((TokenKind::Eq, _)) => { self.next(); - sink(Highlight::Token { text: "&=", class: Some(Class::Op) }); + sink(Highlight::Token { text: "&=", class: None }); return; } - Some((TokenKind::Whitespace, _)) => Class::Op, + Some((TokenKind::Whitespace, _)) => return no_highlight(sink), Some((TokenKind::Ident, "mut")) => { self.next(); sink(Highlight::Token { text: "&mut", class: Some(Class::RefKeyWord) }); @@ -553,7 +550,7 @@ impl<'a> Classifier<'a> { TokenKind::Eq => match lookahead { Some(TokenKind::Eq) => { self.next(); - sink(Highlight::Token { text: "==", class: Some(Class::Op) }); + sink(Highlight::Token { text: "==", class: None }); return; } Some(TokenKind::Gt) => { @@ -561,7 +558,7 @@ impl<'a> Classifier<'a> { sink(Highlight::Token { text: "=>", class: None }); return; } - _ => Class::Op, + _ => return no_highlight(sink), }, TokenKind::Minus if lookahead == Some(TokenKind::Gt) => { self.next(); @@ -578,7 +575,7 @@ impl<'a> Classifier<'a> { | TokenKind::Percent | TokenKind::Bang | TokenKind::Lt - | TokenKind::Gt => Class::Op, + | TokenKind::Gt => return no_highlight(sink), // Miscellaneous, no highlighting. TokenKind::Dot diff --git a/src/librustdoc/html/highlight/fixtures/decorations.html b/src/librustdoc/html/highlight/fixtures/decorations.html index 45f567880c9..ae4dba116d6 100644 --- a/src/librustdoc/html/highlight/fixtures/decorations.html +++ b/src/librustdoc/html/highlight/fixtures/decorations.html @@ -1,2 +1,2 @@ -<span class="example"><span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="number">1</span>;</span> -<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="number">2</span>; \ No newline at end of file +<span class="example"><span class="kw">let</span> <span class="ident">x</span> = <span class="number">1</span>;</span> +<span class="kw">let</span> <span class="ident">y</span> = <span class="number">2</span>; \ No newline at end of file diff --git a/src/librustdoc/html/highlight/fixtures/highlight.html b/src/librustdoc/html/highlight/fixtures/highlight.html index abc2db1790c..17f23278ec1 100644 --- a/src/librustdoc/html/highlight/fixtures/highlight.html +++ b/src/librustdoc/html/highlight/fixtures/highlight.html @@ -1,4 +1,4 @@ <span class="kw">use</span> <span class="ident"><span class="kw">crate</span>::a::foo</span>; <span class="kw">use</span> <span class="ident"><span class="self">self</span>::whatever</span>; -<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident"><span class="kw">super</span>::b::foo</span>; -<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="ident"><span class="self">Self</span>::whatever</span>; \ No newline at end of file +<span class="kw">let</span> <span class="ident">x</span> = <span class="ident"><span class="kw">super</span>::b::foo</span>; +<span class="kw">let</span> <span class="ident">y</span> = <span class="ident"><span class="self">Self</span>::whatever</span>; \ No newline at end of file diff --git a/src/librustdoc/html/highlight/fixtures/sample.html b/src/librustdoc/html/highlight/fixtures/sample.html index b117a12e39f..ea797fd99d3 100644 --- a/src/librustdoc/html/highlight/fixtures/sample.html +++ b/src/librustdoc/html/highlight/fixtures/sample.html @@ -8,23 +8,23 @@ .lifetime { color: #B76514; } .question-mark { color: #ff9011; } </style> -<pre><code><span class="attribute">#![<span class="ident">crate_type</span> <span class="op">=</span> <span class="string">"lib"</span>]</span> +<pre><code><span class="attribute">#![<span class="ident">crate_type</span> = <span class="string">"lib"</span>]</span> <span class="kw">use</span> <span class="ident">std::path</span>::{<span class="ident">Path</span>, <span class="ident">PathBuf</span>}; -<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"linux"</span>)]</span> +<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> = <span class="string">"linux"</span>)]</span> <span class="kw">fn</span> <span class="ident">main</span>() -> () { - <span class="kw">let</span> <span class="ident">foo</span> <span class="op">=</span> <span class="bool-val">true</span> <span class="op">&&</span> <span class="bool-val">false</span> <span class="op">|</span><span class="op">|</span> <span class="bool-val">true</span>; - <span class="kw">let</span> <span class="kw">_</span>: <span class="kw-2">*const</span> () <span class="op">=</span> <span class="number">0</span>; - <span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="kw-2">&</span><span class="ident">foo</span>; - <span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="op">&&</span><span class="ident">foo</span>; - <span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="kw-2">*</span><span class="ident">foo</span>; + <span class="kw">let</span> <span class="ident">foo</span> = <span class="bool-val">true</span> && <span class="bool-val">false</span> || <span class="bool-val">true</span>; + <span class="kw">let</span> <span class="kw">_</span>: <span class="kw-2">*const</span> () = <span class="number">0</span>; + <span class="kw">let</span> <span class="kw">_</span> = <span class="kw-2">&</span><span class="ident">foo</span>; + <span class="kw">let</span> <span class="kw">_</span> = &&<span class="ident">foo</span>; + <span class="kw">let</span> <span class="kw">_</span> = <span class="kw-2">*</span><span class="ident">foo</span>; <span class="macro">mac!</span>(<span class="ident">foo</span>, <span class="kw-2">&mut</span> <span class="ident">bar</span>); - <span class="macro">assert!</span>(<span class="self">self</span>.<span class="ident">length</span> <span class="op"><</span> <span class="ident">N</span> <span class="op">&&</span> <span class="ident">index</span> <span class="op"><</span><span class="op">=</span> <span class="self">self</span>.<span class="ident">length</span>); + <span class="macro">assert!</span>(<span class="self">self</span>.<span class="ident">length</span> < <span class="ident">N</span> && <span class="ident">index</span> <= <span class="self">self</span>.<span class="ident">length</span>); <span class="ident">::std::env::var</span>(<span class="string">"gateau"</span>).<span class="ident">is_ok</span>(); <span class="attribute">#[<span class="ident">rustfmt::skip</span>]</span> - <span class="kw">let</span> <span class="ident">s</span>:<span class="ident">std::path::PathBuf</span> <span class="op">=</span> <span class="ident">std::path::PathBuf::new</span>(); - <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">String::new</span>(); + <span class="kw">let</span> <span class="ident">s</span>:<span class="ident">std::path::PathBuf</span> = <span class="ident">std::path::PathBuf::new</span>(); + <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> = <span class="ident">String::new</span>(); <span class="kw">match</span> <span class="kw-2">&</span><span class="ident">s</span> { <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">x</span> => {} diff --git a/src/librustdoc/html/highlight/fixtures/union.html b/src/librustdoc/html/highlight/fixtures/union.html index c0acf31a05d..ac8bd28f6c3 100644 --- a/src/librustdoc/html/highlight/fixtures/union.html +++ b/src/librustdoc/html/highlight/fixtures/union.html @@ -4,5 +4,5 @@ } <span class="kw">fn</span> <span class="ident">main</span>() { - <span class="kw">let</span> <span class="ident">union</span> <span class="op">=</span> <span class="number">0</span>; + <span class="kw">let</span> <span class="ident">union</span> = <span class="number">0</span>; } diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs index 2ed7a6f1bb1..6f029c66c0b 100644 --- a/src/librustdoc/html/render/context.rs +++ b/src/librustdoc/html/render/context.rs @@ -301,13 +301,10 @@ impl<'tcx> Context<'tcx> { /// may happen, for example, with externally inlined items where the source /// of their crate documentation isn't known. pub(super) fn src_href(&self, item: &clean::Item) -> Option<String> { - self.href_from_span(item.span(self.tcx()), true) + self.href_from_span(item.span(self.tcx())?, true) } pub(crate) fn href_from_span(&self, span: clean::Span, with_lines: bool) -> Option<String> { - if span.is_dummy() { - return None; - } let mut root = self.root_path(); let mut path = String::new(); let cnum = span.cnum(self.sess()); diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index 09c54969ef1..5ed5299e09b 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -2677,7 +2677,7 @@ fn render_call_locations(w: &mut Buffer, cx: &mut Context<'_>, item: &clean::Ite let contents = match fs::read_to_string(&path) { Ok(contents) => contents, Err(err) => { - let span = item.span(tcx).inner(); + let span = item.span(tcx).map_or(rustc_span::DUMMY_SP, |span| span.inner()); tcx.sess .span_err(span, &format!("failed to read file {}: {}", path.display(), err)); return false; diff --git a/src/librustdoc/html/sources.rs b/src/librustdoc/html/sources.rs index f508808a8b6..f37c54e4298 100644 --- a/src/librustdoc/html/sources.rs +++ b/src/librustdoc/html/sources.rs @@ -53,6 +53,7 @@ impl LocalSourcesCollector<'_, '_> { fn add_local_source(&mut self, item: &clean::Item) { let sess = self.tcx.sess; let span = item.span(self.tcx); + let Some(span) = span else { return }; // skip all synthetic "files" if !is_real_and_local(span, sess) { return; @@ -109,6 +110,7 @@ impl DocVisitor for SourceCollector<'_, '_> { let tcx = self.cx.tcx(); let span = item.span(tcx); + let Some(span) = span else { return }; let sess = tcx.sess; // If we're not rendering sources, there's nothing to do. diff --git a/src/librustdoc/html/static/css/themes/ayu.css b/src/librustdoc/html/static/css/themes/ayu.css index 39a4dae3348..b8218867a8b 100644 --- a/src/librustdoc/html/static/css/themes/ayu.css +++ b/src/librustdoc/html/static/css/themes/ayu.css @@ -238,7 +238,7 @@ details.rustdoc-toggle > summary::before { pre.rust .number, pre.rust .string { color: #b8cc52; } pre.rust .kw, pre.rust .kw-2, pre.rust .prelude-ty, pre.rust .bool-val, pre.rust .prelude-val, -pre.rust .op, pre.rust .lifetime { color: #ff7733; } +pre.rust .lifetime { color: #ff7733; } pre.rust .macro, pre.rust .macro-nonterminal { color: #a37acc; } pre.rust .question-mark { color: #ff9011; @@ -250,7 +250,7 @@ pre.rust .self { pre.rust .attribute { color: #e6e1cf; } -pre.rust .attribute .ident, pre.rust .attribute .op { +pre.rust .attribute .ident { color: #e6e1cf; } diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs index 4c21fd55328..5f3793ead42 100644 --- a/src/librustdoc/json/conversions.rs +++ b/src/librustdoc/json/conversions.rs @@ -59,7 +59,7 @@ impl JsonRenderer<'_> { id: from_item_id_with_name(item_id, self.tcx, name), crate_id: item_id.krate().as_u32(), name: name.map(|sym| sym.to_string()), - span: self.convert_span(span), + span: span.and_then(|span| self.convert_span(span)), visibility: self.convert_visibility(visibility), docs, attrs, @@ -428,10 +428,8 @@ impl FromWithTcx<clean::GenericBound> for GenericBound { use clean::GenericBound::*; match bound { TraitBound(clean::PolyTrait { trait_, generic_params }, modifier) => { - // FIXME: should `trait_` be a clean::Path equivalent in JSON? - let trait_ = clean::Type::Path { path: trait_ }.into_tcx(tcx); GenericBound::TraitBound { - trait_, + trait_: trait_.into_tcx(tcx), generic_params: generic_params.into_tcx(tcx), modifier: from_trait_bound_modifier(modifier), } @@ -460,12 +458,7 @@ impl FromWithTcx<clean::Type> for Type { }; match ty { - clean::Type::Path { path } => Type::ResolvedPath { - name: path.whole_name(), - id: from_item_id(path.def_id().into(), tcx), - args: path.segments.last().map(|args| Box::new(args.clone().args.into_tcx(tcx))), - param_names: Vec::new(), - }, + clean::Type::Path { path } => Type::ResolvedPath(path.into_tcx(tcx)), clean::Type::DynTrait(bounds, lt) => Type::DynTrait(DynTrait { lifetime: lt.map(convert_lifetime), traits: bounds.into_tcx(tcx), @@ -487,16 +480,22 @@ impl FromWithTcx<clean::Type> for Type { mutable: mutability == ast::Mutability::Mut, type_: Box::new((*type_).into_tcx(tcx)), }, - QPath { assoc, self_type, trait_, .. } => { - // FIXME: should `trait_` be a clean::Path equivalent in JSON? - let trait_ = clean::Type::Path { path: trait_ }.into_tcx(tcx); - Type::QualifiedPath { - name: assoc.name.to_string(), - args: Box::new(assoc.args.clone().into_tcx(tcx)), - self_type: Box::new((*self_type).into_tcx(tcx)), - trait_: Box::new(trait_), - } - } + QPath { assoc, self_type, trait_, .. } => Type::QualifiedPath { + name: assoc.name.to_string(), + args: Box::new(assoc.args.clone().into_tcx(tcx)), + self_type: Box::new((*self_type).into_tcx(tcx)), + trait_: trait_.into_tcx(tcx), + }, + } + } +} + +impl FromWithTcx<clean::Path> for Path { + fn from_tcx(path: clean::Path, tcx: TyCtxt<'_>) -> Path { + Path { + name: path.whole_name(), + id: from_item_id(path.def_id().into(), tcx), + args: path.segments.last().map(|args| Box::new(args.clone().args.into_tcx(tcx))), } } } @@ -565,10 +564,7 @@ impl FromWithTcx<clean::PolyTrait> for PolyTrait { clean::PolyTrait { trait_, generic_params }: clean::PolyTrait, tcx: TyCtxt<'_>, ) -> Self { - PolyTrait { - trait_: clean::Type::Path { path: trait_ }.into_tcx(tcx), - generic_params: generic_params.into_tcx(tcx), - } + PolyTrait { trait_: trait_.into_tcx(tcx), generic_params: generic_params.into_tcx(tcx) } } } @@ -576,8 +572,6 @@ impl FromWithTcx<clean::Impl> for Impl { fn from_tcx(impl_: clean::Impl, tcx: TyCtxt<'_>) -> Self { let provided_trait_methods = impl_.provided_trait_methods(tcx); let clean::Impl { unsafety, generics, trait_, for_, items, polarity, kind } = impl_; - // FIXME: should `trait_` be a clean::Path equivalent in JSON? - let trait_ = trait_.map(|path| clean::Type::Path { path }.into_tcx(tcx)); // FIXME: use something like ImplKind in JSON? let (synthetic, blanket_impl) = match kind { clean::ImplKind::Normal | clean::ImplKind::FakeVaradic => (false, None), @@ -595,7 +589,7 @@ impl FromWithTcx<clean::Impl> for Impl { .into_iter() .map(|x| x.to_string()) .collect(), - trait_, + trait_: trait_.map(|path| path.into_tcx(tcx)), for_: for_.into_tcx(tcx), items: ids(items, tcx), negative: negative_polarity, diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 0fe720e70cf..8aede1e77a2 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -8,7 +8,6 @@ #![feature(box_patterns)] #![feature(control_flow_enum)] #![feature(drain_filter)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(test)] #![feature(never_type)] diff --git a/src/librustdoc/passes/calculate_doc_coverage.rs b/src/librustdoc/passes/calculate_doc_coverage.rs index 4c6e3eb040d..48835abf952 100644 --- a/src/librustdoc/passes/calculate_doc_coverage.rs +++ b/src/librustdoc/passes/calculate_doc_coverage.rs @@ -215,7 +215,6 @@ impl<'a, 'b> DocVisitor for CoverageCalculator<'a, 'b> { None, ); - let filename = i.span(self.ctx.tcx).filename(self.ctx.sess()); let has_doc_example = tests.found_tests != 0; // The `expect_def_id()` should be okay because `local_def_id_to_hir_id` // would presumably panic if a fake `DefIndex` were passed. @@ -261,13 +260,16 @@ impl<'a, 'b> DocVisitor for CoverageCalculator<'a, 'b> { let should_have_docs = !should_be_ignored && (level != lint::Level::Allow || matches!(source, LintLevelSource::Default)); - debug!("counting {:?} {:?} in {:?}", i.type_(), i.name, filename); - self.items.entry(filename).or_default().count_item( - has_docs, - has_doc_example, - should_have_doc_example(self.ctx, i), - should_have_docs, - ); + if let Some(span) = i.span(self.ctx.tcx) { + let filename = span.filename(self.ctx.sess()); + debug!("counting {:?} {:?} in {:?}", i.type_(), i.name, filename); + self.items.entry(filename).or_default().count_item( + has_docs, + has_doc_example, + should_have_doc_example(self.ctx, i), + should_have_docs, + ); + } } } diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs index ecdecadd2ef..7dcad66b1f9 100644 --- a/src/rustdoc-json-types/lib.rs +++ b/src/rustdoc-json-types/lib.rs @@ -9,7 +9,7 @@ use std::path::PathBuf; use serde::{Deserialize, Serialize}; /// rustdoc format-version. -pub const FORMAT_VERSION: u32 = 17; +pub const FORMAT_VERSION: u32 = 18; /// A `Crate` is the root of the emitted JSON blob. It contains all type/documentation information /// about the language items in the local crate, as well as info about external items to allow @@ -133,7 +133,7 @@ pub struct DynTrait { /// A trait and potential HRTBs pub struct PolyTrait { #[serde(rename = "trait")] - pub trait_: Type, + pub trait_: Path, /// Used for Higher-Rank Trait Bounds (HRTBs) /// ```text /// dyn for<'a> Fn() -> &'a i32" @@ -447,7 +447,7 @@ pub enum WherePredicate { pub enum GenericBound { TraitBound { #[serde(rename = "trait")] - trait_: Type, + trait_: Path, /// Used for Higher-Rank Trait Bounds (HRTBs) /// ```text /// where F: for<'a, 'b> Fn(&'a u8, &'b u8) @@ -481,12 +481,7 @@ pub enum Term { #[serde(tag = "kind", content = "inner")] pub enum Type { /// Structs, enums, and traits - ResolvedPath { - name: String, - id: Id, - args: Option<Box<GenericArgs>>, - param_names: Vec<GenericBound>, - }, + ResolvedPath(Path), DynTrait(DynTrait), /// Parameterized types Generic(String), @@ -527,11 +522,25 @@ pub enum Type { args: Box<GenericArgs>, self_type: Box<Type>, #[serde(rename = "trait")] - trait_: Box<Type>, + trait_: Path, }, } #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct Path { + pub name: String, + pub id: Id, + /// Generic arguments to the type + /// ```test + /// std::borrow::Cow<'static, str> + /// ^^^^^^^^^^^^^^ + /// | + /// this part + /// ``` + pub args: Option<Box<GenericArgs>>, +} + +#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] pub struct FunctionPointer { pub decl: FnDecl, /// Used for Higher-Rank Trait Bounds (HRTBs) @@ -574,7 +583,7 @@ pub struct Impl { pub generics: Generics, pub provided_trait_methods: Vec<String>, #[serde(rename = "trait")] - pub trait_: Option<Type>, + pub trait_: Option<Path>, #[serde(rename = "for")] pub for_: Type, pub items: Vec<Id>, diff --git a/src/stage0.json b/src/stage0.json index aa80d08e084..36bb348ae58 100644 --- a/src/stage0.json +++ b/src/stage0.json @@ -17,349 +17,349 @@ "tool is executed." ], "compiler": { - "date": "2022-07-16", + "date": "2022-08-09", "version": "beta" }, "rustfmt": { - "date": "2022-07-21", + "date": "2022-08-09", "version": "nightly" }, "checksums_sha256": { - "dist/2022-07-16/cargo-beta-aarch64-apple-darwin.tar.gz": "d114c9c7d39fa092e291d39eeed2cac5ec67a9d7f1e392014f83629dffd500f6", - "dist/2022-07-16/cargo-beta-aarch64-apple-darwin.tar.xz": "d3d0090e4afb944da8ae9b6b5441486e03066e83de69a2a9606a51444e601196", - "dist/2022-07-16/cargo-beta-aarch64-pc-windows-msvc.tar.gz": "99d64f68bdbeff55552efe0860a2170db6c0cda155a7a955322d4ccfced2a2e7", - "dist/2022-07-16/cargo-beta-aarch64-pc-windows-msvc.tar.xz": "209b0514a99341bdcaf62ad4785b807383aff2572105f143e89fc89f67bea0d4", - "dist/2022-07-16/cargo-beta-aarch64-unknown-linux-gnu.tar.gz": "6dc3c9f6739418e14d5d505b1f215c12768d9db2cc26912cae09ec75d6a5b336", - "dist/2022-07-16/cargo-beta-aarch64-unknown-linux-gnu.tar.xz": "741f7d7a55fcab360d6e0d91e0f83bf8ee6aaf19b0e880a7c3e91af22a4d7ca9", - "dist/2022-07-16/cargo-beta-aarch64-unknown-linux-musl.tar.gz": "15185b7f4b806cf8dd5e785625df73efa27a5653e8c38476040372f372a11b1f", - "dist/2022-07-16/cargo-beta-aarch64-unknown-linux-musl.tar.xz": "0122b5d493383d97d39d6593bd9cc709a1809f29f1713d3553ae242b78047e34", - "dist/2022-07-16/cargo-beta-arm-unknown-linux-gnueabi.tar.gz": "e3e2b281ff1233f6596b27db8b593252867d7f26c1ce91b779a164234d2cfd86", - "dist/2022-07-16/cargo-beta-arm-unknown-linux-gnueabi.tar.xz": "0c71da4b8daeab00da01bca07eef363c5a17a03c1eaf48014d3508c7f228e24b", - "dist/2022-07-16/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz": "6bce124d863189178f06cf430466c18d9ba0cd0e42851e18bb38254d00bdad64", - "dist/2022-07-16/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz": "0ae2a35e0e4f2946dd78420b11f17a54a370e15e12367ba29b63e3f087fb0c71", - "dist/2022-07-16/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz": "eee82cd57578eade5cbc07cf3d48be243a4789e6fba6d7db5772038f87e243f9", - "dist/2022-07-16/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz": "e27b8fe73df64a2733002007503995d9f914d16f852d5e643ac539408086435d", - "dist/2022-07-16/cargo-beta-i686-pc-windows-gnu.tar.gz": "0aa99ee73efa4940ffd6789f98d3774bf33a3a54c579759b1f9f0e92cb403134", - "dist/2022-07-16/cargo-beta-i686-pc-windows-gnu.tar.xz": "244a98bc858d800a1a36018d7b9fbb77471842b9a130301f9dc19e427c336fb2", - "dist/2022-07-16/cargo-beta-i686-pc-windows-msvc.tar.gz": "6b19412e037eb918b05e993ab1c62d96da8cbf92b0a9fc1480a76ad2dc331f0f", - "dist/2022-07-16/cargo-beta-i686-pc-windows-msvc.tar.xz": "0420980cc9381249bb187c274f42472997e6283acf95bebf1f93b50d5c138942", - "dist/2022-07-16/cargo-beta-i686-unknown-linux-gnu.tar.gz": "95d0e17823ee02ebc3d73982e54b96a110afbf97656ed581da0e71e2635cfb51", - "dist/2022-07-16/cargo-beta-i686-unknown-linux-gnu.tar.xz": "75a65a917ad25c1927c9c8306e76d13989f1ea42c6ca063269685e33811e1fb1", - "dist/2022-07-16/cargo-beta-mips-unknown-linux-gnu.tar.gz": "ac12e969fc6a892621ce9ffa2108a21381033800526d3b0dc6c1dd343b10af09", - "dist/2022-07-16/cargo-beta-mips-unknown-linux-gnu.tar.xz": "3be48fe74c14e48c084fe395b9eef153d97fca57dfc12b5a07f2de143c5df4fc", - "dist/2022-07-16/cargo-beta-mips64-unknown-linux-gnuabi64.tar.gz": "1727662c7307c3fec52663d356ccc147dd0c2608cd5607f83057a3f2f315e578", - "dist/2022-07-16/cargo-beta-mips64-unknown-linux-gnuabi64.tar.xz": "47b32153e287a972d6b7278a7d9b2339d16e8d9a938a42221536d12762d0df92", - "dist/2022-07-16/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "14d56231996a7c20e91c204658412142b8288668109d46f3ed9771186937fff5", - "dist/2022-07-16/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "83410621415f07b345d6989fd146303594c811449fd5e3c7609158a9404ba236", - "dist/2022-07-16/cargo-beta-mipsel-unknown-linux-gnu.tar.gz": "5362caf0bd6af50fc4bd89864beddcc909d1d53d0ce2b4049eca4b9019b9d922", - "dist/2022-07-16/cargo-beta-mipsel-unknown-linux-gnu.tar.xz": "6b5007890a41aead77f919ad7ff0fc29c32e460ab3402837ea0e6ded21f2e4c0", - "dist/2022-07-16/cargo-beta-powerpc-unknown-linux-gnu.tar.gz": "e4c914ef7b6e97aeb437d0fb2100f0fe621519ef8f6bdee98a4b3e731d5626d6", - "dist/2022-07-16/cargo-beta-powerpc-unknown-linux-gnu.tar.xz": "33a77edf6f85fc2ea790a10c3108811c0ccb22a0c4c0d1e3a6c3ba27c43ab6d9", - "dist/2022-07-16/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz": "85969807dc0d2999fe4dffdb0f8290bfeaf65646cf333924a933adaa4b045d05", - "dist/2022-07-16/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz": "b36b74e1032d6f83da8b18847df80d52fdf3375b2d45140020452e35c2b9af00", - "dist/2022-07-16/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz": "203402c33bb81ed9c176ee7579fde97671b2f32ad5e7fb3200cd1b77f434d52b", - "dist/2022-07-16/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz": "1bf1daa9660d4fe96e7b9d35fde4995e0e12efcdcb0247cb574495d20de080a1", - "dist/2022-07-16/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz": "a5aec71139c49fb950c03bb4b6af19bac0eec2d6ba2520e49c2d1a08eeae36ee", - "dist/2022-07-16/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz": "f0c5b7813073502316e25b71ab41eb600baffd8e51d6ad8134bf14aee53820ac", - "dist/2022-07-16/cargo-beta-s390x-unknown-linux-gnu.tar.gz": "b64be7c8c471c9b4a2d9380ecf7d23431b1ea255bd080635ba58380a820cbe23", - "dist/2022-07-16/cargo-beta-s390x-unknown-linux-gnu.tar.xz": "a0a6f204ce1f38482939caeb2efe645b60760e8b4c7a68ee4edcf51fc93409d7", - "dist/2022-07-16/cargo-beta-x86_64-apple-darwin.tar.gz": "9ab770b4d43ca4020c40b2c234867b67d99794945bb274382f69f9d1e4b0d042", - "dist/2022-07-16/cargo-beta-x86_64-apple-darwin.tar.xz": "66201509e2d1eb5b447f85b019467a2193fb9d3eaa12df025aff6746a47f49a7", - "dist/2022-07-16/cargo-beta-x86_64-pc-windows-gnu.tar.gz": "295bfb182c85aad35fa5c25691acb03c037a28a8178b9b049df88d40176e418b", - "dist/2022-07-16/cargo-beta-x86_64-pc-windows-gnu.tar.xz": "c1d4578521feb07b04c38b5431eb93830d518bbee47bb458e8f745a7bbd4b312", - "dist/2022-07-16/cargo-beta-x86_64-pc-windows-msvc.tar.gz": "7eda4ebd7d8ade6e62772604bd6fe1a64f7123da1002c22810a752906893429d", - "dist/2022-07-16/cargo-beta-x86_64-pc-windows-msvc.tar.xz": "7eb53b58d63c3f11faf58c819da9bf828f47b579904f9cc801a97b044bb7814c", - "dist/2022-07-16/cargo-beta-x86_64-unknown-freebsd.tar.gz": "cce8a7f5d0e561ab9ede68e535b601396a7a46c2737d01b9c9f008b6cf4b510f", - "dist/2022-07-16/cargo-beta-x86_64-unknown-freebsd.tar.xz": "c1989f0a6bb75c8ae4fb56fac60c880a62e92dbb225fa86b5383242573e62e9a", - "dist/2022-07-16/cargo-beta-x86_64-unknown-illumos.tar.gz": "eb5a4e9bd6a2216e4b72afb5bc542d49583a23a3bb3146ef2c02aa9f15887d24", - "dist/2022-07-16/cargo-beta-x86_64-unknown-illumos.tar.xz": "42c5330ba2ce1b8e4045e7b8671ad1254bc2d6119bc34996467c5956108897f9", - "dist/2022-07-16/cargo-beta-x86_64-unknown-linux-gnu.tar.gz": "35fcf80d8cb8bcc5ab413128575bc6a843c145b4b748df2de9cc9697d535fb6b", - "dist/2022-07-16/cargo-beta-x86_64-unknown-linux-gnu.tar.xz": "4070423142b86fac1ad312ea74880456343fbfe2f5f73e465993b21f4f019b93", - "dist/2022-07-16/cargo-beta-x86_64-unknown-linux-musl.tar.gz": "4d3adc8d1cc15d45a4e7498965b92b9313cce8fa9a8f1391000d4dbe0258603a", - "dist/2022-07-16/cargo-beta-x86_64-unknown-linux-musl.tar.xz": "2a39a68b74b7a62fb89f4ccbd202679fed65b425c1678451ac268b94c8294228", - "dist/2022-07-16/cargo-beta-x86_64-unknown-netbsd.tar.gz": "8508973b3595a0b0a65050d761c108119251a57ba3013d4942f65d0f4f634a7a", - "dist/2022-07-16/cargo-beta-x86_64-unknown-netbsd.tar.xz": "4309d7b2c2c26e454fee473e0345947b7447b6e107f795ce9d4cedfca3baa199", - "dist/2022-07-16/rust-std-beta-aarch64-apple-darwin.tar.gz": "2168776e63da0bb2b6d09e90510f0d481c68d4aaaa1e1cfc79317add45a01d5a", - "dist/2022-07-16/rust-std-beta-aarch64-apple-darwin.tar.xz": "bb9a83c1b5468e740a9b444052afe91a3d8d3223acdf1626e4302475f864acdd", - "dist/2022-07-16/rust-std-beta-aarch64-apple-ios-sim.tar.gz": "44f00f44ee97a5f05b156a0be66151fefb79452b94b5d764564702194fb84ba1", - "dist/2022-07-16/rust-std-beta-aarch64-apple-ios-sim.tar.xz": "b06f7599e3024cea98f90ea4a9dc0fac9d458dcce63aecc2497e2ec15a00eda8", - "dist/2022-07-16/rust-std-beta-aarch64-apple-ios.tar.gz": "35d7c8d11aac14f2e4ce3a1e236a8e59642a6be1e474be7d741c0e38ffcb9d5d", - "dist/2022-07-16/rust-std-beta-aarch64-apple-ios.tar.xz": "7fef57b2788303b10b267c228b80f6347c437a10dd2b77bea71e7280a11db008", - "dist/2022-07-16/rust-std-beta-aarch64-fuchsia.tar.gz": "d83d4186e499853f337513b5603c4cdf287012bc121a33537eb514b2d47e8963", - "dist/2022-07-16/rust-std-beta-aarch64-fuchsia.tar.xz": "92d3caab76907cea85fe78c10f902661ea0887c6689888f6eb9fffa2f443339f", - "dist/2022-07-16/rust-std-beta-aarch64-linux-android.tar.gz": "82ca00fd9913e2d55bc0ecf06313a2f9004f71c40c44f01b3d7d9cd8d1799fb0", - "dist/2022-07-16/rust-std-beta-aarch64-linux-android.tar.xz": "dc7c287887bba704fe988e7f5f7d080aff576de7a214f1dc63ded4fc784eba0b", - "dist/2022-07-16/rust-std-beta-aarch64-pc-windows-msvc.tar.gz": "fe47ed76b388f7b01d5e3d1d51918beb0f04ca7e015353479f7eff78e49b9794", - "dist/2022-07-16/rust-std-beta-aarch64-pc-windows-msvc.tar.xz": "0bcece81cf9b81c5ace02459f945b97be181f81704cade21687460f1db00343a", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz": "9f28057d4828f7a07eeefd8eb03c9e807babd86e67443099491421f7c5afa67f", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz": "b21f0deee74041385b7018979e7db1dfd071530f064b1bc500f9281cfafc38cc", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-linux-musl.tar.gz": "588d6952722ec461de5d0c10c5f01c6d6735740a74b8162e2e2ebb848f9175d4", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-linux-musl.tar.xz": "c6731bcd0e4e15d79dcdc6f974b5a4f7a379692ad2183c0bfd56e6619d9f0fe1", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz": "588585fd26813de3ae2a8a49c6e6fea5f0f7311911a54c015372010883cf5938", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz": "a5e820bbbf113250c4f814dd0f4aaa9b20b1a7d61613b7157993d25fb0ff3518", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-none.tar.gz": "69ec1ef2f456a8cd294ec3f7c485f45401e6f200df9f525419726cf9da60dc60", - "dist/2022-07-16/rust-std-beta-aarch64-unknown-none.tar.xz": "b13d0099a55a928dfbfe07d80426e9bd53b6e35cfc6b634ad2ee02174ce42f7a", - "dist/2022-07-16/rust-std-beta-arm-linux-androideabi.tar.gz": "a90a4cc72263b96ada453dd3c8443d076ec150ed910ad30f26f825cd668516e9", - "dist/2022-07-16/rust-std-beta-arm-linux-androideabi.tar.xz": "0d7c8c13a18888cd7e9613c7d88ef227d9b2034739d0d16507aca28403328b42", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz": "9fcd72dfd5568a3e7023c416720ba4d5e42aa6d425c7ce6feb2ebf1b650d7591", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz": "43efd4e1ca95f54fef097f14483a4f4d96d499c38c5ad3d3a290e02f7c4c4637", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz": "7d2c708aaeb01014856ee7d2c6c4c85883f17fd00fca912aabb93d84170e3e61", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz": "97d3c092fd702dc7df0df83722046371b4d418aabc60fbbf0807ddddf3e7dcda", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-musleabi.tar.gz": "74e8fe4152eb12ee8b9d4fd4e3cfe5d506329c94ab515319fb2aaf013bacea5f", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-musleabi.tar.xz": "a207d79cf57f3e13b6f85761373a00fa8afde8f513e14a3e0c0a70f40d89e890", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz": "4660ec4d1fe1960e70b54bce58cae6775b8df86c3ecbc96f4df0067dcd90a3cf", - "dist/2022-07-16/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz": "c86a999f7affd8f4d2e0d509cf3e2229a3cd40768ef86b1ac36b5dccbbe56bdf", - "dist/2022-07-16/rust-std-beta-armebv7r-none-eabi.tar.gz": "5ecc032c10a8f8d3e1e40256ca7c7e03cc98ae35d56105f70df94a4519412dbb", - "dist/2022-07-16/rust-std-beta-armebv7r-none-eabi.tar.xz": "8e2c1c97083aa141d3b31476903a6325fd11f0ae5350909eb0295b8be19eb1f8", - "dist/2022-07-16/rust-std-beta-armebv7r-none-eabihf.tar.gz": "e111491ee2412c8d770b0a93fe402566e46c2faa855c71f24da77a989f36ea2a", - "dist/2022-07-16/rust-std-beta-armebv7r-none-eabihf.tar.xz": "7c814fece60ece924f5dffff6ee6f1605965841f4b864cd271c5c4f3b3c18042", - "dist/2022-07-16/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz": "0d4e93aa2f04f1d255d319653b3f4c02bd3557cc8227e6be4e0f1769aeadd2a8", - "dist/2022-07-16/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz": "d60246292f63abeb9eb35ddf93901ea9f75cba358a67589595aa1cfc9d35e6aa", - "dist/2022-07-16/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz": "085e236212a908e0e363d78dd3ce8c676cd2dbc8e817601486502389ba8d0734", - "dist/2022-07-16/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz": "654e655cb257dbed0490ec0c75e0cc0b7e35512d4f6f9f5dddc10bab0cd02098", - "dist/2022-07-16/rust-std-beta-armv7-linux-androideabi.tar.gz": "10fb120b0269a65f554a592e05ec26703b0888dbeaf06c15b43522b730c943cd", - "dist/2022-07-16/rust-std-beta-armv7-linux-androideabi.tar.xz": "470eec8bd47f66409e28eac2b86b5c6c0644531c91135637f667f54edb7fd6a9", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz": "520e83ebeb2dd29fea43087399af6227fe90b5a571572322301cc6d9b76f5027", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz": "a7527bcd5ee6017de7fde1a6f1d98db831e7bddf5a64b54ce12cadafaa3d560b", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz": "bb0ac318b0a5dd972356f4e94789b68caae1a14e5996493a3bed1a579bb1145d", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz": "cc1e65bf50246be9d9578487580038a7015f3a61444dc53afb7c4f2afc8181f8", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz": "7ff2051b2324f51bf0b3fe7581e1b5e02c4e2fb4075950c36716e8ba783b1b42", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz": "d4e32fcf2da983adc8db7043175cded76e56894f136766c5d9afe08ef6f0e766", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz": "6f7b86e7b51ba9d8187c61ff0d7a6d28fe65201bc94b94bd5a845490fbcff3e4", - "dist/2022-07-16/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz": "3ac410ea3f641b578ec1183856306b1eb4e0d02ba58534df114ab45a91fafd1d", - "dist/2022-07-16/rust-std-beta-armv7a-none-eabi.tar.gz": "abe93aa78a72eda2735d2f78cc98ea9b7a50752320d83b70464bac86a4a765ee", - "dist/2022-07-16/rust-std-beta-armv7a-none-eabi.tar.xz": "059560de23b47a43800319fc968a5dd34d44ab61f486a8f33a075798c66f0528", - "dist/2022-07-16/rust-std-beta-armv7r-none-eabi.tar.gz": "b08a4b0b56d86182e735d5dc6f47083a4f8a0101b4a712e02f14c9f3d1720001", - "dist/2022-07-16/rust-std-beta-armv7r-none-eabi.tar.xz": "d65cb28ea5f5cb7e5649a85a591609b5f49c0e3b0d02c1ff8d2b1dc10ea3b4a3", - "dist/2022-07-16/rust-std-beta-armv7r-none-eabihf.tar.gz": "cb13a879797483d7a7fd2073be2af0c83f98c4226e81ea0333670eddffc4f77e", - "dist/2022-07-16/rust-std-beta-armv7r-none-eabihf.tar.xz": "4965ee9c27d6104f572bcfd19944e19a3f70d58a5d0d215059f2cc52f7bc9c1e", - "dist/2022-07-16/rust-std-beta-asmjs-unknown-emscripten.tar.gz": "e8437c9df42118b8607723c1e4f04a7b7a302e9894dc52ab8c212f07964ac994", - "dist/2022-07-16/rust-std-beta-asmjs-unknown-emscripten.tar.xz": "b05f10cee7b5c8aeea44689c11ddfe6f266a8779dfb0fa9df51c7c784f9f31a6", - "dist/2022-07-16/rust-std-beta-i586-pc-windows-msvc.tar.gz": "65f66e8690c742b13c3371c1af4219d701b66f61e4fd984b1d67bb89d6468566", - "dist/2022-07-16/rust-std-beta-i586-pc-windows-msvc.tar.xz": "cabea5fef3004aee4c3108a47fba945f434bd29b4c55250236ec009405e41b36", - "dist/2022-07-16/rust-std-beta-i586-unknown-linux-gnu.tar.gz": "8349e67b9760f9c257c745c4d87015bd623e1cf073703429f64400f7dc9c1210", - "dist/2022-07-16/rust-std-beta-i586-unknown-linux-gnu.tar.xz": "ee6473059771a8f49ce5ca8f36913a9ef31be3def32c63c5a31f50a896aa565e", - "dist/2022-07-16/rust-std-beta-i586-unknown-linux-musl.tar.gz": "7edb1155a5fab3c123e0a847c0397b6c347cd7b4a6a15996d93f45281c2d8eb1", - "dist/2022-07-16/rust-std-beta-i586-unknown-linux-musl.tar.xz": "49360ce15d751ef01403459fe3eaa30061160a79e4454eee7f5c63fc65a3666d", - "dist/2022-07-16/rust-std-beta-i686-linux-android.tar.gz": "5d62f8e1b15b44998f7b039b7e6ab7deff85ba13130a11309b2541c70834538a", - "dist/2022-07-16/rust-std-beta-i686-linux-android.tar.xz": "4b2e1b2835919299113d28eca09b1e12471054786156da0cb63bc0620d6afe00", - "dist/2022-07-16/rust-std-beta-i686-pc-windows-gnu.tar.gz": "39a9c3f2392240b29f52ed525f57d548537e7cc7a57438bd84f7efbd85b49811", - "dist/2022-07-16/rust-std-beta-i686-pc-windows-gnu.tar.xz": "d8ae971791693c23260b73c8faf94570a1bddbcecfa9c339fbd23682c8cd2bb5", - "dist/2022-07-16/rust-std-beta-i686-pc-windows-msvc.tar.gz": "e57020d959cbe2e7331808f425e8d95e5204f4e9c33cdd301c6809aa06ba6d90", - "dist/2022-07-16/rust-std-beta-i686-pc-windows-msvc.tar.xz": "35b4504603903e7c753487585fcc75237f4f8a0ee933c52941abaf2c6913e0f0", - "dist/2022-07-16/rust-std-beta-i686-unknown-freebsd.tar.gz": "dd5c6dd4fe4bfb1acdda726ac9f6fa0944f745be946ed175a8e3c62c0d4c46f7", - "dist/2022-07-16/rust-std-beta-i686-unknown-freebsd.tar.xz": "95a9f3bcce8780522d678822cac8b06ba662112df51afa312f4c7ed76a3987ed", - "dist/2022-07-16/rust-std-beta-i686-unknown-linux-gnu.tar.gz": "52b49a92f66cbc2b250a7272f58acfb9732fdb7073baa430b47ff9ebfe0c98a2", - "dist/2022-07-16/rust-std-beta-i686-unknown-linux-gnu.tar.xz": "2f6b5de99c83cdd01c44b388ea059d10ee7f0f62ca17547b7a6d8d66fdf349f4", - "dist/2022-07-16/rust-std-beta-i686-unknown-linux-musl.tar.gz": "24d81d4d181c86dc02fe5b3fb54c50f78f72f73c2d9c319710d275fb08a53980", - "dist/2022-07-16/rust-std-beta-i686-unknown-linux-musl.tar.xz": "32c99f24396601c8a4afb250cda4718d6d5fae57f9534d5c3c3962e4c076d261", - "dist/2022-07-16/rust-std-beta-mips-unknown-linux-gnu.tar.gz": "d476561d571d62d31c03b57fd380591acbb809fd4f26873e2ef2e4b3f583da46", - "dist/2022-07-16/rust-std-beta-mips-unknown-linux-gnu.tar.xz": "93d3d0511508351f5e3322a3e4360586c2c2bdb60ca0c4aaea4fe5e7da081e92", - "dist/2022-07-16/rust-std-beta-mips-unknown-linux-musl.tar.gz": "d8c354f83a5481508a88fa6ced6fb458458678ddfa7814e47415b5daa66b0470", - "dist/2022-07-16/rust-std-beta-mips-unknown-linux-musl.tar.xz": "19f272db8772fa7b77cb9d5e1c56a1a2062a6e087b2980131128ab01b025f571", - "dist/2022-07-16/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.gz": "775aaac7be36438ce4e8f1cda3926c3540f90fc9b74e387d5e4497227ceaad97", - "dist/2022-07-16/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.xz": "bc460e80f4fd82492cc8e66f11320ef22c71fe26a4255606c73c325bbd2f8516", - "dist/2022-07-16/rust-std-beta-mips64-unknown-linux-muslabi64.tar.gz": "7ebb73739bafa8f412756575f4033b45629b62a92a35460bb37f3f691640bcc9", - "dist/2022-07-16/rust-std-beta-mips64-unknown-linux-muslabi64.tar.xz": "1483cde530d3d50116f4dbcb42a3b22cf7bb04559cc9bebd762f82e8b3ebea40", - "dist/2022-07-16/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "a7f813851b5a9c67ba16c80da5b80397db1f4c9b5a10f4877f52b6861b856b1d", - "dist/2022-07-16/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "3fd132910d46fb9d769d8697e81b89aff7f739d9b197e4a54b00797e217a0a66", - "dist/2022-07-16/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.gz": "8ddc74476e1023ee58ee5564d7357082cbba2a7d930abd7c704dbdf49439e2cf", - "dist/2022-07-16/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.xz": "f773cbcfb9010491f92cbeeccff0dfc8109d4407af4c10269766674a51e84b68", - "dist/2022-07-16/rust-std-beta-mipsel-unknown-linux-gnu.tar.gz": "85bebea249c436f016fddef2865850adcb16585cccd6fd4fbd9baf0be971160c", - "dist/2022-07-16/rust-std-beta-mipsel-unknown-linux-gnu.tar.xz": "74a519aa2b595b093510b81b0c65b9a864dc2cb3cb4ff5af8619531afd436b8a", - "dist/2022-07-16/rust-std-beta-mipsel-unknown-linux-musl.tar.gz": "f8dcb0e03629d23715e7cba213b91753d99a9e0ce8b0111e360a8c6e062b9f41", - "dist/2022-07-16/rust-std-beta-mipsel-unknown-linux-musl.tar.xz": "e2ad66f17aca663689d80e59b6ab854fe27aabda318c0ae41febf9fff700ac7f", - "dist/2022-07-16/rust-std-beta-nvptx64-nvidia-cuda.tar.gz": "6351ee40b19c7981f9b4aa2900bda8cf6fec04f5953bca78c0f480f885b78425", - "dist/2022-07-16/rust-std-beta-nvptx64-nvidia-cuda.tar.xz": "8c8f6ca9717ef1f4168d9ac4c4eb0f771149dcbc77ee4ec179031b10f9de13a2", - "dist/2022-07-16/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz": "706d3e633e8fdbc8f672153f16638ed2ade39321beefde054f63864bfac4e9af", - "dist/2022-07-16/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz": "0b7b37b4eee8fcccad684d606aa5b326f60473ed9f567cd2d17def4cbd8c3b63", - "dist/2022-07-16/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz": "40a2572f1a4297bef43708d1dafd1709373a0258f2bbe7914a9f954ca4dbe2f0", - "dist/2022-07-16/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz": "78ebece93dd1b8e6825d6026444484f0beca982d802651149da32b13d8de69c3", - "dist/2022-07-16/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz": "4a362a752fb6270c75fc24dc7cae00a70d4272972b1f0409a0a32582d1293acd", - "dist/2022-07-16/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz": "f1b8eb010818955e3ed21b2b4e3c42180fa817dcc0aa6b75520149fccd2b9d1c", - "dist/2022-07-16/rust-std-beta-riscv32i-unknown-none-elf.tar.gz": "0eb83977d0fb83eb498ff7858edd3fdfc0a2e40efa859a23b9a03972fd0f0c10", - "dist/2022-07-16/rust-std-beta-riscv32i-unknown-none-elf.tar.xz": "b39894ecc6fd00b8398b1430285d7876f8955eeae43949e54a45a0e374ad8c37", - "dist/2022-07-16/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz": "402e022a2a7f1eb06e91ba883532b6354e94dbd1314a7ab406f37e56026e6097", - "dist/2022-07-16/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz": "97762f1261461a996626dc922f7d2b9791d38d216e871065d1c9f3fe21dd10e2", - "dist/2022-07-16/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz": "0999c8f23113ed6cdb98f0751779d90fe368d6b322a49506dd5df96e9c00ce0b", - "dist/2022-07-16/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz": "7b289c284b7b53f7f12b05f841be6d6024dc581bbe59abf07402d87f87b78231", - "dist/2022-07-16/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz": "f6a71af82c15e20aa20881fdf0daa5815c2c9589c6fab1a69fade2380c9c740c", - "dist/2022-07-16/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz": "3adc7fd340e08b482259eece4c1abc210ec32f97fe6d5fdf6847ddeebe7e8e10", - "dist/2022-07-16/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz": "2136b39139393e6b9454b0c84a0c25256a444a940b9a6c207fddc7ef2b25a22d", - "dist/2022-07-16/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz": "ec9f3f7c62dd6fcc5339579d5becd5e5542c0eb45b415b91a9a2b6ebde18bd7c", - "dist/2022-07-16/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz": "79e21a41c5400e646f4ff76d8c4c0bea12501338742ce800093ee1e06d0d6932", - "dist/2022-07-16/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz": "f686a014f19efed6d8357d0ff88702779a0132bc412cd1e6eb93b535ebf26686", - "dist/2022-07-16/rust-std-beta-s390x-unknown-linux-gnu.tar.gz": "45a9dbab6143f10131f702c446768e542180572033811060947d4a1d79a7c2a0", - "dist/2022-07-16/rust-std-beta-s390x-unknown-linux-gnu.tar.xz": "eefcfb4558b26145aebfafb193420972be8d8e6ca1b8d83a648ab9718cdbf97b", - "dist/2022-07-16/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz": "96e69f7db947588df72b49975b53387a02d102eb1295ecc8712f5cdcf0191ba7", - "dist/2022-07-16/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz": "10c2dfa886225fdcd991db70c0ae077432a9ace7f69c5464222555f1cbe9b51c", - "dist/2022-07-16/rust-std-beta-sparcv9-sun-solaris.tar.gz": "254a8a83f480947878a377feb64803e6b396a967e07957513741aa7aa3ef6a07", - "dist/2022-07-16/rust-std-beta-sparcv9-sun-solaris.tar.xz": "a18a04dfdcb6fecea8376908114690e0ca5ca54b2aced5e922f463799483d882", - "dist/2022-07-16/rust-std-beta-thumbv6m-none-eabi.tar.gz": "643b8d6e5b17aa5ed0696550439039651e178695348dfb11567520e0439091a3", - "dist/2022-07-16/rust-std-beta-thumbv6m-none-eabi.tar.xz": "9cb7f0543dfd4f13b6126a6de336a6b11eea9a241cdbbf00290ed0c7a1d331ea", - "dist/2022-07-16/rust-std-beta-thumbv7em-none-eabi.tar.gz": "58d094491df31e051e9fc85d4376df165ef103651b676e494beba2b689382254", - "dist/2022-07-16/rust-std-beta-thumbv7em-none-eabi.tar.xz": "5e44398411718fb4cd22bc13a5fd091adb23938c2010d45ce63ac0a547435406", - "dist/2022-07-16/rust-std-beta-thumbv7em-none-eabihf.tar.gz": "186ac77a1844786df52e5325e9aacd519db8f61ab72cd08376e8af869ce71e22", - "dist/2022-07-16/rust-std-beta-thumbv7em-none-eabihf.tar.xz": "737d50c6ad0f0918580b29bdf3cf811f43a49fc5fcfd3b4e5f0cfdfde4acbf15", - "dist/2022-07-16/rust-std-beta-thumbv7m-none-eabi.tar.gz": "7e6bb04375764e3c80f2d477b2a982baa170339029a8c3f99caeefb280acd95e", - "dist/2022-07-16/rust-std-beta-thumbv7m-none-eabi.tar.xz": "e15af6e720e2b19884a1bfa3b6c2d394082786bf95483b0962ed134d7787161c", - "dist/2022-07-16/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz": "80a32a6988b945861eb834f3bfc0cbbf594a0b2b7cb1594f150e7ac8f2919065", - "dist/2022-07-16/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz": "75f986807dbeb40418b049264334580cf0d324db80e3e86d047d65e6ebb50a2b", - "dist/2022-07-16/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz": "d86a80418c9cc9b883faf2b5e681b530ea09c550fb39b9e558a381ab67d3f43f", - "dist/2022-07-16/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz": "30af6048b67ee64c378250b23227383b799c598aa24e3a09cf50baa4e15a9833", - "dist/2022-07-16/rust-std-beta-thumbv8m.base-none-eabi.tar.gz": "ed57999629478f3d1efd164249bb471eaf866a95da7c0916572bd0537f40c964", - "dist/2022-07-16/rust-std-beta-thumbv8m.base-none-eabi.tar.xz": "232f3099d833785dc6e50dadb205ade5440e850ec24821cdd24a534a19b93cb1", - "dist/2022-07-16/rust-std-beta-thumbv8m.main-none-eabi.tar.gz": "56ea2a0a2ff89efaeb791df36751cd6493161878e281d3dce507f9637044e304", - "dist/2022-07-16/rust-std-beta-thumbv8m.main-none-eabi.tar.xz": "820b1c2fa96e952a09b32ba0a5a94239bf69ecde2bdcb769d073f35e5ee13383", - "dist/2022-07-16/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz": "a1b9d35ed7346f43025a354c38e5836340c1be3a9b2173845c91afe7bbfadfc4", - "dist/2022-07-16/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz": "e3da59132bdef040b4618037f9d7f0c38511701420a676c9d451544cbfda0ce4", - "dist/2022-07-16/rust-std-beta-wasm32-unknown-emscripten.tar.gz": "e92dce094d5c503c3a66c7419f4b2b341a0647678596f6c5ec5ddebaa4107905", - "dist/2022-07-16/rust-std-beta-wasm32-unknown-emscripten.tar.xz": "b7a2e4db89f9dde15b51dea0044b57204326898e351fcb45df1da31c5edbe929", - "dist/2022-07-16/rust-std-beta-wasm32-unknown-unknown.tar.gz": "608834a5a7d60024e2f7275ac5615d7dc1c1723b2195695eb889dbd633a45e2c", - "dist/2022-07-16/rust-std-beta-wasm32-unknown-unknown.tar.xz": "646cbf64202df1f11d829d371810867e12120e12266895125b53600e4d678d26", - "dist/2022-07-16/rust-std-beta-wasm32-wasi.tar.gz": "b1802f8dd97e213466bdaaa769ef4b03ea1baf5cd14475edba8b70dd6736b855", - "dist/2022-07-16/rust-std-beta-wasm32-wasi.tar.xz": "f47bf0b5aaea9d52deea681b85daab38920db504168fb9a0eeea161996eaf494", - "dist/2022-07-16/rust-std-beta-x86_64-apple-darwin.tar.gz": "cd5be7559517ea844335c88e3cd5846990cad18bbb4dd96c1c1add6d873b5ef3", - "dist/2022-07-16/rust-std-beta-x86_64-apple-darwin.tar.xz": "3e028523c2a23a5681b6a9f4ed4f4313bbc0295f3f0e986e0c6bffad69454368", - "dist/2022-07-16/rust-std-beta-x86_64-apple-ios.tar.gz": "7c18b0d86b4cb7da00139112966e86de05da9286fea72458056dbf1607eab774", - "dist/2022-07-16/rust-std-beta-x86_64-apple-ios.tar.xz": "4aeaf6925f7a591a7ff0449d98b1ee5b1fd2fbca93e8bfb7fd2b279ecd2ec2ed", - "dist/2022-07-16/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz": "62ac06824cb70a0b02292ccdca9ae4e2660644fa9a0abb186c73d64e9632c733", - "dist/2022-07-16/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz": "8642bd83f1bf709d38260ee54fbb4de679bbec802d5c72f09e1146e82195577a", - "dist/2022-07-16/rust-std-beta-x86_64-fuchsia.tar.gz": "caf561a7b5efb474c9db48dd5ac3ceb32505f60813324b2665fadc639e6103e1", - "dist/2022-07-16/rust-std-beta-x86_64-fuchsia.tar.xz": "c6481548b0ef6b9c4a82b1f697842cb7c38176acb06699d559c825243fbbaf4a", - "dist/2022-07-16/rust-std-beta-x86_64-linux-android.tar.gz": "be110f47348bc63d27b541af4093167cd48d5f011897482ca7a940abcfeeb1a7", - "dist/2022-07-16/rust-std-beta-x86_64-linux-android.tar.xz": "11ccae4e0bfc76df7bd33d858fe47ead9294cd0707aee3f42ac3683a140d583f", - "dist/2022-07-16/rust-std-beta-x86_64-pc-solaris.tar.gz": "78d6662fbfb469c7cb0b2f381523ebab1b566edf2dfa676c8a509a6d584e17f2", - "dist/2022-07-16/rust-std-beta-x86_64-pc-solaris.tar.xz": "034be03c974835fa0d2747364c8b26f50d83762316d4a266473972622e2627d6", - "dist/2022-07-16/rust-std-beta-x86_64-pc-windows-gnu.tar.gz": "759eed3f19e2c8203a7b03ab90eedf4b09e0edfff9fea49bcb2fc795aef66a4f", - "dist/2022-07-16/rust-std-beta-x86_64-pc-windows-gnu.tar.xz": "119c6fbaa021130baa881738164810d7829ee54234e8adb6e82f1f6cba9da876", - "dist/2022-07-16/rust-std-beta-x86_64-pc-windows-msvc.tar.gz": "b0369c5804ab496b5ae9a2643f5da959e62cf574d394d3a74a06524816bd2fc6", - "dist/2022-07-16/rust-std-beta-x86_64-pc-windows-msvc.tar.xz": "130b922369beb56a30666dfb6f36881105e5446284f196eef6817939f94f1b02", - "dist/2022-07-16/rust-std-beta-x86_64-sun-solaris.tar.gz": "5405406252ab897de56c46023de48c08d03fce7791e7db06c009d10e4c9c03f3", - "dist/2022-07-16/rust-std-beta-x86_64-sun-solaris.tar.xz": "b91c6f6dfbe142102a8d72b5c91f8efd1873c20e73e34d9240898a08f63d6be3", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-freebsd.tar.gz": "17526319a486038ef77e7a0f8c1ffbc6e43b4ac3eef4d14c4b70307cbd937c5e", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-freebsd.tar.xz": "8cccb4640373abd1f17418c5b7d5198e8da3af3886206dff559fa2e23c4994e2", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-illumos.tar.gz": "ff3f98720355eede902bc3c12d5ecdfc6e7f53b70133492e26b4cd464ff585f2", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-illumos.tar.xz": "73531fe83d87304fe54adee9ede87e82220afd4dcb5c1a27878a1d9dd7dce9d9", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz": "936855bb97c47c0978caa65748515e3e7550916beb5d06aa569dab6192738886", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz": "e8b95205019e5f73e86247da9f5dab22f8ceaa98f6afa8f0eb7c6d92a258b97e", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz": "2f016727a0d761960923f4a83cce489d2f4d87b354352d109be1e89ad45f99e4", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz": "16f0829deae2df1fee609dfae7ec51bbcb7da5a9dcfe48f4d517d07934463b42", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-linux-musl.tar.gz": "8bb4f4c9bb114cdee7c3d95c78e66f9c574ae47116b3aa0401712eb29c41461f", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-linux-musl.tar.xz": "8a4977f3bb54c0f260c4b41f2fc7bf0fb06fd69e6eb9a9c88c438274f7ea993d", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-netbsd.tar.gz": "2b361b36d6a6f917b17a92b68dc9fb80c05e0b90a1987f4761b05ecb970ef4c6", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-netbsd.tar.xz": "5a4069a5ee239d289e13f8071c3fab252dab944706c2e223f763107509730fda", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-none.tar.gz": "d4b0d375705732ac44da55e5272bde7c0756231bed205fabfa5b8b265e0d8e79", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-none.tar.xz": "5d4f05830dc0530d60e0d570e692b0c4d7ee48e68d4bb3838878fead474bc063", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-redox.tar.gz": "c43fb78286169bcdede9e092d84a9f2e7762ad67bdd2ed7a14d6d3234af52b9e", - "dist/2022-07-16/rust-std-beta-x86_64-unknown-redox.tar.xz": "905d5a8f6f642a978e55afc45329f6b7b6083a34ec6f51de0bb854685c5e3add", - "dist/2022-07-16/rustc-beta-aarch64-apple-darwin.tar.gz": "86afdc287964673c25d3c625b5bf03231d897d46fe8565e1078747e7b85bc627", - "dist/2022-07-16/rustc-beta-aarch64-apple-darwin.tar.xz": "8cd87fd24927617793bb06edc581184edfc12de7c961f03a530aee7eb793166f", - "dist/2022-07-16/rustc-beta-aarch64-pc-windows-msvc.tar.gz": "6c2858cc584d845ebcb8cc4dbadc5b0bf4e875dd0920b2d9106791b8bb7567e7", - "dist/2022-07-16/rustc-beta-aarch64-pc-windows-msvc.tar.xz": "dde2c77b23b8ecedbec8427c3b8f6a889d96b053de74787a73faef366cdb30c1", - "dist/2022-07-16/rustc-beta-aarch64-unknown-linux-gnu.tar.gz": "5ff5ae57cc7eacf26a3410c499d23e520ed9ef20f7aa50e77a3354a7bbed541f", - "dist/2022-07-16/rustc-beta-aarch64-unknown-linux-gnu.tar.xz": "850f4456625e7ae545c3036338b5bdcb1982a2fca4d1664efc835630a7e42468", - "dist/2022-07-16/rustc-beta-aarch64-unknown-linux-musl.tar.gz": "5409263cbb71867780c8a2bcce126665217632d8eb7e4dab95c199ebfee8755e", - "dist/2022-07-16/rustc-beta-aarch64-unknown-linux-musl.tar.xz": "deeeff68790e4857d625fdc1e0ed430e4d31b4e5e87b5534d899cdf7fec2adf5", - "dist/2022-07-16/rustc-beta-arm-unknown-linux-gnueabi.tar.gz": "0701e5f5d04db2cc677366ec769fa3f6c39351a9527f8493fd54d29086294a00", - "dist/2022-07-16/rustc-beta-arm-unknown-linux-gnueabi.tar.xz": "a133838e0eb1d9177fe0c052667ba9820a6ba5cbba604a80ad732ca5c1e23846", - "dist/2022-07-16/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz": "9ad3ad6c0c27d50238f83821b526a1d6f598ff293a36381d0a8a28cbd0a7ab4e", - "dist/2022-07-16/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz": "3313866d0d78c82b0b571e889d6ed85fce80dc2ea3dcc495f4738672e8d3b972", - "dist/2022-07-16/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz": "0459cf4a11cc6d41aa95d837b73a339fbf1c50ecfc078a95705c110d03a9c941", - "dist/2022-07-16/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz": "16b092bd7fccc84d6776f8cf3794c302b258fe9b3bf2adcc2ba1551197d3ab92", - "dist/2022-07-16/rustc-beta-i686-pc-windows-gnu.tar.gz": "c3c49711e23a87fb78d2a85d4838893963f151918464708f61cbd0a0ef8d6841", - "dist/2022-07-16/rustc-beta-i686-pc-windows-gnu.tar.xz": "eac7e88ef96b4eb99d5f15e168c7b782f0c9bfced92e5852559414e4c95a18c4", - "dist/2022-07-16/rustc-beta-i686-pc-windows-msvc.tar.gz": "fe6f0c952dccbe7262678615c8a850ce76f510295202427a16755005f3505744", - "dist/2022-07-16/rustc-beta-i686-pc-windows-msvc.tar.xz": "bd596d7e1fac9b4e02a036aa1e59819317d210044b3298bf4ec3633817f2ec2b", - "dist/2022-07-16/rustc-beta-i686-unknown-linux-gnu.tar.gz": "5dbbdd77e606ad28421a39d9ec95d2254e2658033247d94a733dec05a2368cb5", - "dist/2022-07-16/rustc-beta-i686-unknown-linux-gnu.tar.xz": "f9471eb60265b18f755c76dc4786895804fdc2b0ed8c8c8e58a454dbd1eca3b3", - "dist/2022-07-16/rustc-beta-mips-unknown-linux-gnu.tar.gz": "e4e8e67a0c4240ccb478631ee3b7a0fcc22d68b2adce26228f5fc9fff34dc03c", - "dist/2022-07-16/rustc-beta-mips-unknown-linux-gnu.tar.xz": "c7879912b5b6bfbaea4b424562ac1174bab8e30a4d20b3a82291b606a5a5f09e", - "dist/2022-07-16/rustc-beta-mips64-unknown-linux-gnuabi64.tar.gz": "3b437ea0fe1c9f52505cc7e5cfe2b3b103973e3ba3c132ba304d828c210e7eb1", - "dist/2022-07-16/rustc-beta-mips64-unknown-linux-gnuabi64.tar.xz": "d1c144f58626f3b0df9a24ffe5db9b2df45a410071df551fec48e0a7097bb17a", - "dist/2022-07-16/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "364647a234f7d40095d38cf01fcbdf554128436829d2972cb22f91fde18b346a", - "dist/2022-07-16/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "fc2c9200111139a051c8e3bb41f936b2126d24ca91ba175d88de95d59b6e00da", - "dist/2022-07-16/rustc-beta-mipsel-unknown-linux-gnu.tar.gz": "884a0da049f646196964f6cf93f03d9211e3864b39190432ee2e369c34051717", - "dist/2022-07-16/rustc-beta-mipsel-unknown-linux-gnu.tar.xz": "d82cd504ff34e741c9cf246fd6d8829f8af74d36670de46daea858a2c282f286", - "dist/2022-07-16/rustc-beta-powerpc-unknown-linux-gnu.tar.gz": "0fdd190eec39c72972d8d4df7fb59c77ffd9e9fad4d219264b6ceaa301c0250f", - "dist/2022-07-16/rustc-beta-powerpc-unknown-linux-gnu.tar.xz": "e74704b5c21a77c3d1dd7f265a7f24e9f904405afc3170d5f3836c8d28105ee0", - "dist/2022-07-16/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz": "90c1480f585ad1d9e0c3b564f5eb87667eedf5992ce46f73d6462dbb9a136182", - "dist/2022-07-16/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz": "e5b3e75d5d85e84fbf8c0d4b8e1f4c20421e1d20c18805f413f785d594c14a4c", - "dist/2022-07-16/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz": "5163f545aca9e56edb0510c30eb9343dbdd95ce3704677cdbebcb70947437838", - "dist/2022-07-16/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz": "f6c61e0c2bb404f248986287dcf7f4bcf8458fd17e678bbb53c43ce5ef19d5eb", - "dist/2022-07-16/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz": "fce64768b803f67470e093422926f44cf621eca5052eff4d9c6b89b94556b411", - "dist/2022-07-16/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz": "e99f1ae947b812047c4367d87f0f4dde6581c0af02240625500b1ddc9133025e", - "dist/2022-07-16/rustc-beta-s390x-unknown-linux-gnu.tar.gz": "c6bb4bd5eaea57d15dd995de614471aeaddd103158e609ecdf43177f1843c25b", - "dist/2022-07-16/rustc-beta-s390x-unknown-linux-gnu.tar.xz": "8e54cc288f3bb2a268fe37f2815ce94c3810438aefdfab9dd679ef572dbc127b", - "dist/2022-07-16/rustc-beta-x86_64-apple-darwin.tar.gz": "dc06d6cc19934b091cb3894c42debf6189f7b2d54162cc93418cb8851c967154", - "dist/2022-07-16/rustc-beta-x86_64-apple-darwin.tar.xz": "2f177aa386c389ce18ec47495d5c48d5512bee00aed0e3dad53809fbdb81f55a", - "dist/2022-07-16/rustc-beta-x86_64-pc-windows-gnu.tar.gz": "e6af40fc7d92ddfd3bdab6ed92b8bb614df2ef7158a8f59291593034191d483a", - "dist/2022-07-16/rustc-beta-x86_64-pc-windows-gnu.tar.xz": "5c51250a55d9e424ced7f91a90a801d53bfcf489be033a06c15adfcd587f5e47", - "dist/2022-07-16/rustc-beta-x86_64-pc-windows-msvc.tar.gz": "f4bc463f82baa6681ad7292c512836bde962743b32b28ba118c38622dc3478f4", - "dist/2022-07-16/rustc-beta-x86_64-pc-windows-msvc.tar.xz": "a25e397cd228f44c0280f61621bdbab028fb07a20551a3c1b25606d0eefc4745", - "dist/2022-07-16/rustc-beta-x86_64-unknown-freebsd.tar.gz": "27e0d39b8bdde40899a1486fc39b6bc612068dc4d4db65d52a4b3c85f03675e4", - "dist/2022-07-16/rustc-beta-x86_64-unknown-freebsd.tar.xz": "74f59446e6e6b031fedd12d10380bd33c119b09d0d1435488008f104a4297a97", - "dist/2022-07-16/rustc-beta-x86_64-unknown-illumos.tar.gz": "9b49259f9446ffdc510b80b3cb67084f006cbf86bc6c14e6a6a42128657773eb", - "dist/2022-07-16/rustc-beta-x86_64-unknown-illumos.tar.xz": "2a5b5c0f33dcdf79afce7445d6dd0183ba95f898becfca6eace5858e6836706f", - "dist/2022-07-16/rustc-beta-x86_64-unknown-linux-gnu.tar.gz": "b891c82a6acbb2ee5e3b46c4e5ebfc4a215e70415879425125934b7fa8c33329", - "dist/2022-07-16/rustc-beta-x86_64-unknown-linux-gnu.tar.xz": "e33bf0cd9e7e50469c9cd98c9404aa7495268192e4be70117c75607a9a18bb95", - "dist/2022-07-16/rustc-beta-x86_64-unknown-linux-musl.tar.gz": "f5ed5f80204fa0608e888750866b880575d9eba63bbcd69b71708713a27fe27c", - "dist/2022-07-16/rustc-beta-x86_64-unknown-linux-musl.tar.xz": "3f69e388b687cbdafaf59ca3486eed4dda510652a8ee37fde9efeff096258801", - "dist/2022-07-16/rustc-beta-x86_64-unknown-netbsd.tar.gz": "57eb4ebf820c11e5d4700f6c3ec414e6d2b70475f71579f854aec66650ab9eb3", - "dist/2022-07-16/rustc-beta-x86_64-unknown-netbsd.tar.xz": "979c3d20834c4bdee5b47598fddc26c3e02edd7678ee34faf97ac5f11aa8314b", - "dist/2022-07-21/rustfmt-nightly-aarch64-apple-darwin.tar.gz": "9099fe96569cf008c9bb92f86efe1773a1e6f8542e71af037727d411ca3e4c92", - "dist/2022-07-21/rustfmt-nightly-aarch64-apple-darwin.tar.xz": "085c6086a977725738ee44c4e0b748be255847c740fbce4aec62519afa91c088", - "dist/2022-07-21/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz": "c829b598f2a7d815ddb1772153aa847e5f1fe844710acc01e18f626d5af1daaf", - "dist/2022-07-21/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz": "50d3336081798cf6dffa615e1217845b51f82017375b4b0cf18167a939de0a5c", - "dist/2022-07-21/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz": "40a86effd1d5b60735d15c33090e31a0ed1cccdcca7cece013176071a90f3c93", - "dist/2022-07-21/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz": "ee29ab772f2f24f7f4f8655cbab2a64ad7fd2253ce04a4a72c497cdd18fd71cc", - "dist/2022-07-21/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz": "d739d788caf9190fccbab1a00e42f75bb7e10d94263b556578175bdd11826468", - "dist/2022-07-21/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz": "9775c98de87876ade2a7896e0df6519334ffb21cca12f60afa1874105b7dc75b", - "dist/2022-07-21/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz": "241d9983b1314829b9311bb7e1743e422b81d22342eed7216ba534788df77016", - "dist/2022-07-21/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz": "df50d81cf63dfea4a17f32318d4b4111944323395641ad9f7c989f9f74dbd383", - "dist/2022-07-21/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz": "1953f4f8c244c81e60a97c9480f78c0a3e0373c44ef7c188306ea26a6ff087e1", - "dist/2022-07-21/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz": "296273dfe9ad0ebf0ef47bb0a566050f90ec235bdb3d7776371b0b249466764e", - "dist/2022-07-21/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz": "da67ad4667d2b39862e21d43b9e0a99ad0bbd36ccc936779ed6dacb9b2fd17c2", - "dist/2022-07-21/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz": "efc5eb6d3c6fabdb03b83c9e9215b13955f82ceec62255aafd78db0e28ba8421", - "dist/2022-07-21/rustfmt-nightly-i686-pc-windows-gnu.tar.gz": "e603216f64f6fcf3ca21581dcdd283b41a1b6a59779c7760b8aa79b4c593e7e8", - "dist/2022-07-21/rustfmt-nightly-i686-pc-windows-gnu.tar.xz": "7c5c47faf6f014b63e1193cbf27de51bec82e9811537a17cb9b4922b709618c8", - "dist/2022-07-21/rustfmt-nightly-i686-pc-windows-msvc.tar.gz": "ac605732e74a1c344ea7c6ef84a6ca1823d3ed51024ef895ec9a181a6f91f8c3", - "dist/2022-07-21/rustfmt-nightly-i686-pc-windows-msvc.tar.xz": "7044d68341f8ea2fef122600f3995fff681599dc1a545ab2b45d1b2302fd6436", - "dist/2022-07-21/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz": "b7d57d01a9985826333ecac8447e0a1a5a753cf0ed11770de70d47b59050215b", - "dist/2022-07-21/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz": "13076a20f555c18db2d38deaaf33aeaed0f27b8cb5a2962b26661b6989dc3a5f", - "dist/2022-07-21/rustfmt-nightly-mips-unknown-linux-gnu.tar.gz": "c64ab15040368af0c595102a7232b405b1a52164fe39e06ba189b2a26c70fe9d", - "dist/2022-07-21/rustfmt-nightly-mips-unknown-linux-gnu.tar.xz": "a05b3aa95231a7e6631f0da01869d8cb8b6e3a5c184eb411591583cc78cd3aaf", - "dist/2022-07-21/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.gz": "242650636f9b33adc71a8c1bba1dc3a2928ba7723c976ae5645428b47862c658", - "dist/2022-07-21/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.xz": "7a2a54f05cac08aa65645e099d2597504477bba269b6f74e99f2df397a660eaf", - "dist/2022-07-21/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.gz": "2c3f944a0b8a5b06c4a341882934b737a451baf38f7a902f0794b0f41e1102e3", - "dist/2022-07-21/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.xz": "506e4f89b5243b8c2f6709d69a8b8facad5d7a555b108bed4f689dbd3fe1e46e", - "dist/2022-07-21/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.gz": "fe3a12786f8eecf26213286045a69bc1046d7138a401511618b86b74a70eb66a", - "dist/2022-07-21/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.xz": "37409a8573c5d0c9ea1fd0a745990a4e85f325a87a25c9916dd25617b6059783", - "dist/2022-07-21/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz": "e74050fa0288e7368a9e65f2739498f38ca9c91d36c519674e4590c17d86fcd7", - "dist/2022-07-21/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz": "10da2c6d12e14f4a2c6c9a7f1d2c161a62e4f9956ed7ee100ba31fce9446ea78", - "dist/2022-07-21/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz": "a0cf070555fed25a8aa9f20d704149936dca1ccb7c3aa55aabad2be84a7860f7", - "dist/2022-07-21/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz": "f388ba16822251f2dff0d9fd837dc19c5ca181ebabc93ed81759530d07dce72f", - "dist/2022-07-21/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz": "6056b5c1f46807fce83c4c3e2a443beb66b433e678fb090ca253aef5a87d2927", - "dist/2022-07-21/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz": "642046b17142d6e9ecd207243ed82108088c941b04ee5d8f6b1371b07da60601", - "dist/2022-07-21/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz": "600b5e7a11e3cb583fae2ef9f9dc784c2bef08e355da9e3a37204e0c81a63451", - "dist/2022-07-21/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz": "a9019c838270635f2fe383da5b11fdef2c7b23f838bc5edee7ba5882e7102c63", - "dist/2022-07-21/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz": "613539dc9a67c78216d8d11b0d9baf068d48c4067d628c8144bccec2d899afd1", - "dist/2022-07-21/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz": "55d992631c567da8ea082ca6dfcfdbf4774374ec430050a16001def2221adafe", - "dist/2022-07-21/rustfmt-nightly-x86_64-apple-darwin.tar.gz": "9bade75f59be530972a26618f4e283c89bda864cfd162f47c8d1782d31163148", - "dist/2022-07-21/rustfmt-nightly-x86_64-apple-darwin.tar.xz": "39f21c72c31dc0cf945db142cead8aa8f9208769d8f4336905794ec52848e90e", - "dist/2022-07-21/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz": "3b5cdcc58acad278a1b4eb84dc5aacd8eafe0bd2ac0ab62c5056c918661a9364", - "dist/2022-07-21/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz": "159dd0daacf54993386b2d1cefab13354d9c7614983745d43c28a1a873fbe498", - "dist/2022-07-21/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz": "cfef1baac5ef48912a3d30b3ba6513da50e6a35d1ad8687452dfe64e671effc7", - "dist/2022-07-21/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz": "8c72ca088ae104dd3cd1ce711e083a1816d16876ddd1a07af983d9c22cec1a33", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz": "fdecac3b5e42523e9f5200080f682e3b557b6820ae0f67a02620e1d1fba6f571", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz": "cbf56b942479ee95c89e14b060765ab8e21b2152b2c3e02ffb47957e37cec4cf", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-illumos.tar.gz": "309be4a29a875ba17ed14e351a6aff7a649e0e6897f3d2c3394f2f2ae966a275", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-illumos.tar.xz": "72e6bfd09cb22f8400dbef4017cd09deb2881cdf67df61d4e4d2d2ed5221a683", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz": "d40edc2217657dedee45336aad31289190a7da43bc5620b5d36b7dc0fce1f211", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz": "1df1787f682e9a8bd97a054f76094281fccd4d321c3067e2600860327dd088e3", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz": "91ed27676b13193eecb93839c0c748e667e869f091de88cea4183c51870efbe8", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz": "ccb0245ac982c34c9db9f6ffc3c30769e2b62637a18d88dc30a4ed3c1922fa7e", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz": "54344a42f2fca291c0c10f84386135e2797c9b81519eab0c6db633a95c109f20", - "dist/2022-07-21/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz": "4a276eac1bdace68484b49104b8bb2c48f93a775404f2bd29e9c3d4c6ce7367f" + "dist/2022-08-09/cargo-beta-aarch64-apple-darwin.tar.gz": "5d9f0ee2de50a18124fd506f493cbdf6cb6385944d32aca1aca9dcdf15bdef4d", + "dist/2022-08-09/cargo-beta-aarch64-apple-darwin.tar.xz": "683e8546ab86d98ec84204cdcdd2192d19a98c42c13bf0c69697865641238001", + "dist/2022-08-09/cargo-beta-aarch64-pc-windows-msvc.tar.gz": "fb2a95793d79e04201dcb38fb5ccdb86f1c74503b181a0b3fce0f332e3380bec", + "dist/2022-08-09/cargo-beta-aarch64-pc-windows-msvc.tar.xz": "5b1b826315990487dc0afe561fecd7f937d82bc8d2898742592349c9993cb3c8", + "dist/2022-08-09/cargo-beta-aarch64-unknown-linux-gnu.tar.gz": "23d20d9078154f6f03b3b056607b804ce3e049dfe4d949ccf430556c2f8e79b1", + "dist/2022-08-09/cargo-beta-aarch64-unknown-linux-gnu.tar.xz": "d7a9283bf838c1182e6cc8904b6b464cd9c1dd342078b2447309797868aec7ff", + "dist/2022-08-09/cargo-beta-aarch64-unknown-linux-musl.tar.gz": "fb82a87e759d5ab3536a8edba682793653f51c15d8f27a874ecbff11c991b1fc", + "dist/2022-08-09/cargo-beta-aarch64-unknown-linux-musl.tar.xz": "21de23c600646a3d5a9421761c0411d7e173876278548c42d6a8794abfc5d3d2", + "dist/2022-08-09/cargo-beta-arm-unknown-linux-gnueabi.tar.gz": "d931162577c04807b093d6cedcca989315b15b48f153c790f8ee2ce3edf479dd", + "dist/2022-08-09/cargo-beta-arm-unknown-linux-gnueabi.tar.xz": "797752acf6d0b5814ff1c6e7dd5e54fec0716677c4a11f03143c6e769ed34b1f", + "dist/2022-08-09/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz": "f080f5f486cbfbd09206cca7b70cb051da5e5a68914227a58ee81ecb5ed19c48", + "dist/2022-08-09/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz": "79964e35d780df520ace77ec8035652571709620ba49f14ac7bc59008fd712f8", + "dist/2022-08-09/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz": "339b969dcf283d0cedd0ffea09d534994c5bf588977ecfde61ce87e64090f70d", + "dist/2022-08-09/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz": "601b6b0f58652434d888320851867b9188cb5a99b5f18358b0d7376dd98d4a0a", + "dist/2022-08-09/cargo-beta-i686-pc-windows-gnu.tar.gz": "1c9944d71ff7ed9cd40be1df8fc828e7faa4f5496d917dc6ccc94a1b31839a12", + "dist/2022-08-09/cargo-beta-i686-pc-windows-gnu.tar.xz": "4e3fc72b845b821e3aa1193250a10d494592f3e0917c7716b5bd963d0ad08b73", + "dist/2022-08-09/cargo-beta-i686-pc-windows-msvc.tar.gz": "80559b267ab936cb08a7ef51087e63b61a215df64fa9f5254809705fa31ea3a6", + "dist/2022-08-09/cargo-beta-i686-pc-windows-msvc.tar.xz": "aee6122d25a0bf7e083b45e622858acf34be3e17a1f9964a2f0d9fc7dfdbe164", + "dist/2022-08-09/cargo-beta-i686-unknown-linux-gnu.tar.gz": "5e1f2c32adbdde68b7135d1e4c358076f5dd872c935ac1bbdcbfda0ff43e061f", + "dist/2022-08-09/cargo-beta-i686-unknown-linux-gnu.tar.xz": "f0e6acd5158430866ad0bed435a7e0dbd9f35130b4805b990050b3d9751b4416", + "dist/2022-08-09/cargo-beta-mips-unknown-linux-gnu.tar.gz": "99b71c9001b65408f42e65cf481a905bc30f77edc96401691fb9b122a20009fb", + "dist/2022-08-09/cargo-beta-mips-unknown-linux-gnu.tar.xz": "08d1f3824354af35fb90d6563a7a51775ff9574a9ffe0c87e897e377be778598", + "dist/2022-08-09/cargo-beta-mips64-unknown-linux-gnuabi64.tar.gz": "7dd3dc44fd37af40e587dba68d973b9d2cf40a939a97605a6adee5ba0f589215", + "dist/2022-08-09/cargo-beta-mips64-unknown-linux-gnuabi64.tar.xz": "2f638fc21bb6e11fd59ff07d66a1012d3336d6dbd5b73b2c42461f84415e333d", + "dist/2022-08-09/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "ade7f1ba6f19382980b0a6cbe3e8035932a60c898f7141782921d22398b1cf03", + "dist/2022-08-09/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "2fe5d3b4102320fb1e36198e8d6e43d201986a2c58e4ad45fc2acb23865cf09f", + "dist/2022-08-09/cargo-beta-mipsel-unknown-linux-gnu.tar.gz": "c99aa42005094a65bbeb41deb3499a2fd46032296f6509fd1bf108f7d4cbdd04", + "dist/2022-08-09/cargo-beta-mipsel-unknown-linux-gnu.tar.xz": "7c65e8e6d76cab786f628e4ca02b6af47f6c2c4a36123ee7b8fc059309ce6039", + "dist/2022-08-09/cargo-beta-powerpc-unknown-linux-gnu.tar.gz": "b7b98621ef835f6108c0d1ec60c88d66b462a3daf62ddfc796d31f4e09f7baca", + "dist/2022-08-09/cargo-beta-powerpc-unknown-linux-gnu.tar.xz": "f85473a1d6b33d9b865a6532ea444415c7cfaa3f76af39d637619ffdddd0c00b", + "dist/2022-08-09/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz": "e783ea66457a0aff31489cd42f549a2c9c33cbb2ca0aa253575a59c9de7f73f4", + "dist/2022-08-09/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz": "d90a02cb425320fb5a5b163d87ec03726159994af31b32954c91b1cb9eb3ebf4", + "dist/2022-08-09/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz": "ff1fda58f7bdb9df563172388f66f787a60f75bdd169ef8d2c791b27bbd8c6ce", + "dist/2022-08-09/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz": "df740d61415bf15c62f9656932370e08fea5a289ac25bec78a626e771d24ab7f", + "dist/2022-08-09/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz": "019dfff6fef8c7714dd19c64a5bb408b2b5063367ec1aa8a72960316aa880834", + "dist/2022-08-09/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz": "f8d025d2943b76d665500c9c72aab18a63ecd137e07c10d1463f1905b4274573", + "dist/2022-08-09/cargo-beta-s390x-unknown-linux-gnu.tar.gz": "c379f3c122a9df41b66f13ca3dcb79feb9ae68798c9704dac3018d85ec96d895", + "dist/2022-08-09/cargo-beta-s390x-unknown-linux-gnu.tar.xz": "69bd9bd12f4386c831aaa8e1fac8edf1a0e618d1f6e0e4bcb7be16f1eeb08d81", + "dist/2022-08-09/cargo-beta-x86_64-apple-darwin.tar.gz": "d74acf4f57681527af3a2c469e916bd9dc1ecdb591e16657757db493984de07a", + "dist/2022-08-09/cargo-beta-x86_64-apple-darwin.tar.xz": "00201568ce4b95c6618389ec86e00677a27435276dd1bec16fea44b87a2dce4b", + "dist/2022-08-09/cargo-beta-x86_64-pc-windows-gnu.tar.gz": "3d049963cdda9755e524443a04b0b9c5566cb0e58dc61e13779484d92c3e0f69", + "dist/2022-08-09/cargo-beta-x86_64-pc-windows-gnu.tar.xz": "c8f0c13771e010ed85002ee10e44ad7c0b21ce2ddd105c9b90fbe1896d0687f0", + "dist/2022-08-09/cargo-beta-x86_64-pc-windows-msvc.tar.gz": "796d9da5a59c984a5a78afcfce762134e3a72e52525d0150ebe4bb29d207bd00", + "dist/2022-08-09/cargo-beta-x86_64-pc-windows-msvc.tar.xz": "1ec2764428d4df9355380444158aaa2947c4fe00708e7a30bc6978433621d120", + "dist/2022-08-09/cargo-beta-x86_64-unknown-freebsd.tar.gz": "14643490b1259120b14a7be84942bfd324fdf03dcf473f33f7ae2466fb99f60b", + "dist/2022-08-09/cargo-beta-x86_64-unknown-freebsd.tar.xz": "3af267ab65b3c61b0184f8fb5b5cc5fb61688f9b668654986f30d3a794d9a1a6", + "dist/2022-08-09/cargo-beta-x86_64-unknown-illumos.tar.gz": "5b84826e0e68b6f9769ef7d00b4b1225cb1a4dde1b41f5b6021feb34e7376c63", + "dist/2022-08-09/cargo-beta-x86_64-unknown-illumos.tar.xz": "a1dde17fd13bfb626acd0ae65d88c440a3172e1fdb20aeefda3a205bad71d703", + "dist/2022-08-09/cargo-beta-x86_64-unknown-linux-gnu.tar.gz": "fedfd6a7b8156de19ed2d6b8f354affc4120fe311874e6563b9620634a5d962b", + "dist/2022-08-09/cargo-beta-x86_64-unknown-linux-gnu.tar.xz": "8701ba8c8fcf21623a690d3b7c00d50fc9949035af5aee092ff1239bed4a9784", + "dist/2022-08-09/cargo-beta-x86_64-unknown-linux-musl.tar.gz": "beac64aa92687f975b3a0d5265d7c79ef3962c1d0f0e196296f67bf8e2b803d0", + "dist/2022-08-09/cargo-beta-x86_64-unknown-linux-musl.tar.xz": "8b50c03102cfdf5ffff5fa7b51b0a4d159e24671be5430c77c07256e54a4fd12", + "dist/2022-08-09/cargo-beta-x86_64-unknown-netbsd.tar.gz": "dde29de6d56f02f5cdf35b96287e404ceed85372c3c671ee54972255369470fe", + "dist/2022-08-09/cargo-beta-x86_64-unknown-netbsd.tar.xz": "7e4d07676c4b33af0303436442dc763623784ed20293ed262780267b01843949", + "dist/2022-08-09/rust-std-beta-aarch64-apple-darwin.tar.gz": "63526962ddd66cd6b60f5bb348861caab7a78c7d80515baf4397cab857258d71", + "dist/2022-08-09/rust-std-beta-aarch64-apple-darwin.tar.xz": "64ba52408086b6c7e3578e2ded98528fd63466ec8d7f86045b55a575e0ca780b", + "dist/2022-08-09/rust-std-beta-aarch64-apple-ios-sim.tar.gz": "261109cb02193cfa113697c9d769fcd4d4e265b01dbb4ca0bfa0e0d62f64c71e", + "dist/2022-08-09/rust-std-beta-aarch64-apple-ios-sim.tar.xz": "7f2182b749a8980c2e7b4f31e5a8c72b8a9df8dd2552cda29d061e2236acc589", + "dist/2022-08-09/rust-std-beta-aarch64-apple-ios.tar.gz": "5abe9df533e7bfd62586483f20a1911be5eede5da6114b53b2a000c110e35768", + "dist/2022-08-09/rust-std-beta-aarch64-apple-ios.tar.xz": "2898b8ad95c6a67c2c296c4698acd043cadcb3a2b0449fb7515bfeb48db69a70", + "dist/2022-08-09/rust-std-beta-aarch64-fuchsia.tar.gz": "9f86fcd871ddef0fb86cdfb0084d1bf6fa150bb7cb4dfe3fcade13b75beea5a6", + "dist/2022-08-09/rust-std-beta-aarch64-fuchsia.tar.xz": "4aa91e4f7f3589085c2da45de78a16c48cfe9dd47541928db87ee964c3406b53", + "dist/2022-08-09/rust-std-beta-aarch64-linux-android.tar.gz": "910f4c1ad41d74306e7fdae43c8d04e7fc47724ae84b9276f2d264fbdf2b70f1", + "dist/2022-08-09/rust-std-beta-aarch64-linux-android.tar.xz": "cd60ac333fd684cb730c134cf5a037718254afb9aa65528b2463d76a138f07f7", + "dist/2022-08-09/rust-std-beta-aarch64-pc-windows-msvc.tar.gz": "39740739479c12203c9b6ae7c72f0e542c92750e08b2ca66c5e96355f1eea61f", + "dist/2022-08-09/rust-std-beta-aarch64-pc-windows-msvc.tar.xz": "1c7fb416b404c401f34d4461c61c95ffbaa5b50d8c95d090485aabe12cc78a0c", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz": "8cd2b395607ba16cac4a4fb85f1c5ccf9626849a8e11dc66e911053a6cd1df1b", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz": "c7ef35d4bb2ab6b8ad762349821b6e076851bd5b51dddb7a3b1678b78e21cb42", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-linux-musl.tar.gz": "6410dc79e6e00eca4e483b438ef8a314a55ea6857c618efd50a32a2f95195df8", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-linux-musl.tar.xz": "4d674cbb7d417944a1aaaa23e8c654ac9276529fed3639c75421e1de1e7bfcc2", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz": "1719104655a62e8300df06fb4636543532821c0ac43dcf90435d5fbbf39c12c1", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz": "bf3c12dae8fee831402f9700295d9a6718d6a6046a7e5a0d0748c3f2e3d82224", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-none.tar.gz": "727621bd08ad0e879a79635fb00c187de6d23e0291143b494d3965cacb35d358", + "dist/2022-08-09/rust-std-beta-aarch64-unknown-none.tar.xz": "6b152098c76b2a3367dad676e4c3d328e5d5c89c95504b041e1997e5d141404a", + "dist/2022-08-09/rust-std-beta-arm-linux-androideabi.tar.gz": "c78d9c97e742ef1777679743765de5d475dffe62ea9b60efe2025eb91ba7ba5c", + "dist/2022-08-09/rust-std-beta-arm-linux-androideabi.tar.xz": "1029382048bce0b8e556b87008821f8b4c5c92e30b340c9a8086e32a8ca7f105", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz": "d4b8bb607968ca49d840c1835fc56e92006dd186c7ed71663a23b7495fa392e9", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz": "562dcbfb8ddd31e64939844055c3dbd87a4c04065ad34dbe3a2d87136c0bb4b4", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz": "1d8e8d87ce8f1ee5e8cb946c8b7a92e6f4a56ddd6b3afd1c646e4d5cdb703608", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz": "ce8edce3a2976694a8ca0cff0b296b331f64e0afa6b5cb107bf03e2aff5949c1", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-musleabi.tar.gz": "d57aff420435c76ff8bfaaaa8d94bce62d96299a2a0158b67b9fe914695cc188", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-musleabi.tar.xz": "7eecf0facd3f2dd236e5f731eaf3fbc51b46d1a039f762f5bb42aabd0ab21c00", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz": "6b6341eeca9a48e1c15b03501428ebdd2f591f4196c50d988408a1c591152fb0", + "dist/2022-08-09/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz": "019e36e7c8855ef9d1277d4f5388862412c6d49e7f16d6808d3a6f69c60e5030", + "dist/2022-08-09/rust-std-beta-armebv7r-none-eabi.tar.gz": "41b1cfbcfd16061d52413e0bf2503756ffbe819b4ef2d81f8570e477e0b5893b", + "dist/2022-08-09/rust-std-beta-armebv7r-none-eabi.tar.xz": "209828e95d236ee218a10f468b12d64e4f4bb773a0cbfc247e6f54c2aacdc8a5", + "dist/2022-08-09/rust-std-beta-armebv7r-none-eabihf.tar.gz": "762a5764e926cb081062040cc4f43f8653eab007ac9cb8600751c0f364f17639", + "dist/2022-08-09/rust-std-beta-armebv7r-none-eabihf.tar.xz": "eb9b66ad16ff5c7427112ed5cf73498a02694b7b3af37220e3160bb6a16eca1c", + "dist/2022-08-09/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz": "369b3afe600692f552f7d0bdd310c7b254f8745948e5a4ffff7c5fccf0873ce4", + "dist/2022-08-09/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz": "2cdeb7b58e979bec71aa0a67a95ede5b55ab6ac295b24b08c67e651c4a76b13a", + "dist/2022-08-09/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz": "1a31c291792ba44053c9701d8e665c62155cb319b371359c7f0f9b5b81269f6b", + "dist/2022-08-09/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz": "54b17f4959cff54daf926f33dad8141663366856f691f4ca1015fedf36720022", + "dist/2022-08-09/rust-std-beta-armv7-linux-androideabi.tar.gz": "77ca2251056b76db72b9e8795dfc1b9583544f35dd067435128b2336b33aa892", + "dist/2022-08-09/rust-std-beta-armv7-linux-androideabi.tar.xz": "888b80410a8f9f1f85ec379c4e5490fc18bfb3f7e4954fa66f9b9c27ea92d121", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz": "3b8132040574da39cafbf48cc1e2535ab1c52c51ac2968aaf167911bb4bab648", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz": "915acd9a715cb25db4e899315afbb2b97ad34aee52a7f4536b4e684295e93e8b", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz": "9a1e59513f6812f631fa4926ea794b05524e58cd4d36a55b7a4e286b2e7bd506", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz": "017892f81ce10323b76dd32347d5ba921003177fd95e5d4b4972ad4e84e699c8", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz": "3a7b2f2c4d06135a9ff3931a1a9c0f4431bb3a31763501bbad1dbfb85849e681", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz": "6226c7228337739435cd7194fe3c233250fb2eb8df4dd16c9ef637b2d91c1807", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz": "48b626650f72a7e3885ea2aabbb8c520b079ebda0f798f685392501f1ef7fd79", + "dist/2022-08-09/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz": "627a0be5e0059cc07a4bfd99a0f70e009367c7be6ea45eb4ac0f8554680309e4", + "dist/2022-08-09/rust-std-beta-armv7a-none-eabi.tar.gz": "2489ef3102a8b0ba9885c092309a2e7deaf65721c934a83259fa7f7698440638", + "dist/2022-08-09/rust-std-beta-armv7a-none-eabi.tar.xz": "0e43df943f9550e374ba9334a0bd68f3bd107dc68ee8012f92357aaa0bf3851e", + "dist/2022-08-09/rust-std-beta-armv7r-none-eabi.tar.gz": "edb09fe24634386fe335685bbced045cd7448d1aad520f1cbaa4f0d38f3d38a1", + "dist/2022-08-09/rust-std-beta-armv7r-none-eabi.tar.xz": "2b170a322d07da39e949047871dd28444feaf49d09c901fbdd4015f00e456415", + "dist/2022-08-09/rust-std-beta-armv7r-none-eabihf.tar.gz": "82a69f097820c70c0fdc9b5f22b5378ab1d70d3d35bfec0ebab8b30ad7903178", + "dist/2022-08-09/rust-std-beta-armv7r-none-eabihf.tar.xz": "0301f9984effc3b186531aacb182e65fb57519c5ebd80f445c7346db27dfcc39", + "dist/2022-08-09/rust-std-beta-asmjs-unknown-emscripten.tar.gz": "47bc8975498b6f6afdce3ef7d2d8d4b239b6219f5e4bae9841a82587e1279415", + "dist/2022-08-09/rust-std-beta-asmjs-unknown-emscripten.tar.xz": "0806ef9782068d292106f3fce8b7bf879931fb89efc5e832d85f82bbffa99489", + "dist/2022-08-09/rust-std-beta-i586-pc-windows-msvc.tar.gz": "fb11022f5410c508936617b337d8940d82431544f77366ba6dbc3da81172bd21", + "dist/2022-08-09/rust-std-beta-i586-pc-windows-msvc.tar.xz": "326bc6a7dfe216b03222b187ed424ca6b83325f9a91e0b873d9294c713040a37", + "dist/2022-08-09/rust-std-beta-i586-unknown-linux-gnu.tar.gz": "0a608449de9eca7fbb421263fee19d22a3950f68dee80ca343c8704b2a9fcefb", + "dist/2022-08-09/rust-std-beta-i586-unknown-linux-gnu.tar.xz": "ca980e9d255d4444a329983565eb15807a26c0cdb48bfe763f9fdee061d8a9e4", + "dist/2022-08-09/rust-std-beta-i586-unknown-linux-musl.tar.gz": "db8c6517bb71bf49470b87cc1c9bd180c0421475bad04917be988c0933620db6", + "dist/2022-08-09/rust-std-beta-i586-unknown-linux-musl.tar.xz": "2feccd2d2ec54e25ac36ec2b9ff823887d353c9ca1106a29f8ca0f33f2e5d08a", + "dist/2022-08-09/rust-std-beta-i686-linux-android.tar.gz": "0ce00226f5aa2165d043108650e7444e165ae80c985c62f953b46fd680946b5a", + "dist/2022-08-09/rust-std-beta-i686-linux-android.tar.xz": "e591b8ae11fa7b6b8907d598e159c8795e4c3ff9c2c55e65773c29e488f64550", + "dist/2022-08-09/rust-std-beta-i686-pc-windows-gnu.tar.gz": "51fa05e5fb2d0d310b97c9e255ea3bc5ecb185093013406588cc96fddba18788", + "dist/2022-08-09/rust-std-beta-i686-pc-windows-gnu.tar.xz": "64d87c682eb1a2e0b8abd393358e1880016803bb7da699f2d239ad2d59e0eb0c", + "dist/2022-08-09/rust-std-beta-i686-pc-windows-msvc.tar.gz": "e3c2df5572996ade55a9af5b5b54a84fc0ff2edfcad164f57852ab0d3695d938", + "dist/2022-08-09/rust-std-beta-i686-pc-windows-msvc.tar.xz": "2991215756373d253ffd27a8f650613a5f2bb636adf263b664741772c594241a", + "dist/2022-08-09/rust-std-beta-i686-unknown-freebsd.tar.gz": "bf82e2e7734304f12d3ed5db591ece38a1078b575d92aab8f45328d087cf56ba", + "dist/2022-08-09/rust-std-beta-i686-unknown-freebsd.tar.xz": "73a3b79fe72e835a8b7dfdaba6a1b9c5ee8dde25534fcc520b0ee80a7853b31a", + "dist/2022-08-09/rust-std-beta-i686-unknown-linux-gnu.tar.gz": "74e23ff14e240e935f630e19467bbc9e1b02e9962313dc74f8c444c96bcbfb2e", + "dist/2022-08-09/rust-std-beta-i686-unknown-linux-gnu.tar.xz": "987003e5b23308f31f613a5a133466cd045c05a5998ab29e4d3d8ef15a8342d9", + "dist/2022-08-09/rust-std-beta-i686-unknown-linux-musl.tar.gz": "1c76bac0701c3f9352f4439d2daecb219c08964c6a48ceb212520b4a8e532e02", + "dist/2022-08-09/rust-std-beta-i686-unknown-linux-musl.tar.xz": "7007e60d8ba5e9e40f6aefa248b4881057a9b9a73aa9e7ff0c67a36de7748be3", + "dist/2022-08-09/rust-std-beta-mips-unknown-linux-gnu.tar.gz": "0f6ca4637da137235a3e9315691f1b5c0afc2f853a855458ad6d10ea59ef8579", + "dist/2022-08-09/rust-std-beta-mips-unknown-linux-gnu.tar.xz": "778557cf1c57ada5c1a64ecd58db3a49e8f874217664d53a8be0cfb89b031980", + "dist/2022-08-09/rust-std-beta-mips-unknown-linux-musl.tar.gz": "cbe799d70ca9a24645187d61198c40d495aeed8ef037570ed3cad95b898f6c82", + "dist/2022-08-09/rust-std-beta-mips-unknown-linux-musl.tar.xz": "ab37bff0f1c90a6adb9d603041d5fbe7c94dccfa05a6171145c41335350d02a9", + "dist/2022-08-09/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.gz": "3e5aa74f970a70614751d258b7958696457b03c3f8c6eb2b8e61f3395d9f9169", + "dist/2022-08-09/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.xz": "e32f82fa27968b9f9cc0bad083daae95cc21bc7f56b6fed8e57de39200398248", + "dist/2022-08-09/rust-std-beta-mips64-unknown-linux-muslabi64.tar.gz": "29247f72e5d5563dbfaff65876cd1181943c57121e27a979c11005734825de4f", + "dist/2022-08-09/rust-std-beta-mips64-unknown-linux-muslabi64.tar.xz": "1835664e58cd35261f7387be0746bfd821a8d8108ef8f26dc68db1b4886cc6b6", + "dist/2022-08-09/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "eb6826841be8177bead8edf3d06892219fe7e898e541d2a76539e49c7cf2caa7", + "dist/2022-08-09/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "25c2801f324985094cf3aa9aa56d88e2c73bcd1f7849fdbfd11032fb9d853bc9", + "dist/2022-08-09/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.gz": "573f981b5e197ef337812fb3bcc4ee513121067968d3d33e369426ec51cfdb8e", + "dist/2022-08-09/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.xz": "da6d57cff4999bec0e4249c0b1f1048eae925e793149c60f044b257f306d26bf", + "dist/2022-08-09/rust-std-beta-mipsel-unknown-linux-gnu.tar.gz": "8637387cb7f722457e7cdbb6c75eb70fdb913a5543adb1e4dd81d7316f0d2520", + "dist/2022-08-09/rust-std-beta-mipsel-unknown-linux-gnu.tar.xz": "539a0a66e06fe7b49e40b2615c3d04611236746419bf03f5439b14cc37f3344e", + "dist/2022-08-09/rust-std-beta-mipsel-unknown-linux-musl.tar.gz": "458734ed82bb7e3feb1d831ea6224cd4eeabfbcb06599181d025660298ef7bbe", + "dist/2022-08-09/rust-std-beta-mipsel-unknown-linux-musl.tar.xz": "64f0ce96ae9a99daa300d49d087837c7c619e4bdb38f41664d79844c84254c32", + "dist/2022-08-09/rust-std-beta-nvptx64-nvidia-cuda.tar.gz": "937c3b1481aeab47b45dcb8dc45c12f856a771615c3b6e56b04e10b4f8075d1d", + "dist/2022-08-09/rust-std-beta-nvptx64-nvidia-cuda.tar.xz": "05094bfba7b7fe1fe66f0643ed60079c675d739613e27cb64ca8a61b5faadcd0", + "dist/2022-08-09/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz": "d15c897c52bc02a241e9756c62b48c126d651d498a72a3cc70521e6a395bce7c", + "dist/2022-08-09/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz": "2182c3300e6cf5f7fba5a687235c34fa9e799beef2edbb07206205ede50964ad", + "dist/2022-08-09/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz": "cba214c9827f639f6c88de0bb28f81c58e81f1263b10ccb4fda5c84ad23ea036", + "dist/2022-08-09/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz": "f7f9bb0d56ebd4b80db0560d6f71b25028c97b99f79eb7ef89255d46ca4df22e", + "dist/2022-08-09/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz": "b190a078b408d184766831664df1a2d472a134909ad00f195fb84d522d360a56", + "dist/2022-08-09/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz": "31bcf275272e3a46618110219f61eefd5fdd2c11a75f7ff612fea012dbc3c4b5", + "dist/2022-08-09/rust-std-beta-riscv32i-unknown-none-elf.tar.gz": "eadde81672eda5af55c8f2eff6729ad134dd484ac16aef4fa0e402e0164f30df", + "dist/2022-08-09/rust-std-beta-riscv32i-unknown-none-elf.tar.xz": "2a5d69f4ec463377e2f9eca3a70647680d1ed09bef4f9a7b839d1d08eed989ca", + "dist/2022-08-09/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz": "89b9b9149461362d54b64b2cbdec317674266a9061fc0d46b438f664e003ac83", + "dist/2022-08-09/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz": "3c56a23f2fda148e442318bb5a21d895a5b61cc698db5ea9a1ff3c2740887fc4", + "dist/2022-08-09/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz": "94f9f155ce07f09ca12814b745cce5d6dfc731cc59c95fcd5b1831f60d9c04fb", + "dist/2022-08-09/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz": "b9f76d28c4e057d9b7eada2076c4358d6876aed1c32f65dfa50dc3e3c1970d79", + "dist/2022-08-09/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz": "e664018f445157229a0c07406d3fc4e7a19cb53722fc3838fcee1bbd3a3a00cf", + "dist/2022-08-09/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz": "8d48a304ba7ca9470ed5f88076f6c50477f6b3a1afe303aab772638df8978c32", + "dist/2022-08-09/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz": "347072268911f3a03223bd494cd2d14cfe4c553fc35e9d36571b54995e04d9aa", + "dist/2022-08-09/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz": "100d5a1e75b7c302f03eba8eb26c5c023e1b396cd44d7798f2902bf8f40ec48b", + "dist/2022-08-09/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz": "f5d91e04ac7980aa5253e0c90e7e312e42b5fa7de03f35f61fe11ab207894f50", + "dist/2022-08-09/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz": "0d83e81a8c48f9cc3e62442e51aee769cef4cc618a2661506a5fb9120163be25", + "dist/2022-08-09/rust-std-beta-s390x-unknown-linux-gnu.tar.gz": "96d983517839cbd1d64adfff4b3b0241ceed99573579f041d136be39aa2b7995", + "dist/2022-08-09/rust-std-beta-s390x-unknown-linux-gnu.tar.xz": "0eb2c70b7eeb3f754ffea3716e41dc3efae49e98d77ca1843541587dddd6b880", + "dist/2022-08-09/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz": "91fa2a025c04e41a7b9a7eb6b4cda351b93fc53801f97042ae0e76bd871d92e9", + "dist/2022-08-09/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz": "8ad9da4410688824d5adc6cb8ed42f76bb8a35d41bee62b5f7b44e0d6bd346bb", + "dist/2022-08-09/rust-std-beta-sparcv9-sun-solaris.tar.gz": "cb3a28d68f432a3357b6a971f046b5ea37fdad5d4aaa4aea7cc997356d487b75", + "dist/2022-08-09/rust-std-beta-sparcv9-sun-solaris.tar.xz": "746fb859655ed6b4379fce8937fff998952cb81297412091844b0e277ec65a23", + "dist/2022-08-09/rust-std-beta-thumbv6m-none-eabi.tar.gz": "8bab8c46c7e873d0fa0a7078675fa7a54a90e5342f8b58419e0dd434e9942b67", + "dist/2022-08-09/rust-std-beta-thumbv6m-none-eabi.tar.xz": "954b5c32e5515e09b77bcaa3a7c4e139905a4f3d1801b492069c027a8311bc6b", + "dist/2022-08-09/rust-std-beta-thumbv7em-none-eabi.tar.gz": "9eb56471c38528c2b80dea81d94e5368f68a977745a1e02449f3eae353ca405f", + "dist/2022-08-09/rust-std-beta-thumbv7em-none-eabi.tar.xz": "0334379d0e8c3ef9680837b1dfc96788da4836a91e42d71446461ece7217ab78", + "dist/2022-08-09/rust-std-beta-thumbv7em-none-eabihf.tar.gz": "0c65cc553ca2730d020fd8a97b90ebfe2b3c0fc2755b137df55955a3d1c7908f", + "dist/2022-08-09/rust-std-beta-thumbv7em-none-eabihf.tar.xz": "625a109a589fae6e2fb64376e3fec4bb39ca19217ad6d312df524129868f343b", + "dist/2022-08-09/rust-std-beta-thumbv7m-none-eabi.tar.gz": "e0002c917055c85b613297da21427fc3b6c5f55ee120921ee8bae9b99afec2b6", + "dist/2022-08-09/rust-std-beta-thumbv7m-none-eabi.tar.xz": "74cc0f5b245b483b62c9a9e8bd642069af5205ecc59fd0b7464ab1fd6f4f3f7e", + "dist/2022-08-09/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz": "98c09985ea2d56fcc8c219c46d355310b65fd4f7c6920df2e7ec5355848ba83d", + "dist/2022-08-09/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz": "5122e60b031458c4606905a3df5d64b7bac54bcf883c18ba53443aa76fc5c1cf", + "dist/2022-08-09/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz": "6ab96971e69a073a5789c3eaaa460a7f5d6a3a5df8ac5125344744dde8476706", + "dist/2022-08-09/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz": "be874a256076dd2869d6d5780c5b4e8c850e52a62b5d10087d7c1aca32b0b831", + "dist/2022-08-09/rust-std-beta-thumbv8m.base-none-eabi.tar.gz": "c37ab11b56d3ac41b8eeadbed09ae5e78467c8945cecb49c218fe91a284e43c0", + "dist/2022-08-09/rust-std-beta-thumbv8m.base-none-eabi.tar.xz": "dfa4d1dcfb32d4001b2b9f00a829afd699065dcc6538598eaa27d684a01facac", + "dist/2022-08-09/rust-std-beta-thumbv8m.main-none-eabi.tar.gz": "31931cdb16a9a81bf7fc779c8aef6890c1f35130ba1c323d8b548a5dd5494346", + "dist/2022-08-09/rust-std-beta-thumbv8m.main-none-eabi.tar.xz": "0aeb4ff0e9b139e3b5550103c6429cb3cb4b455335514b07491e22fa63719169", + "dist/2022-08-09/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz": "ba7077816ba6f1b6b386b0245249e10a1482b82eaec711561f912a1975482817", + "dist/2022-08-09/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz": "6a49c1907e0ce91a3650aeeb61f6674c39936b67366fa4bb197fc612e9ae5a49", + "dist/2022-08-09/rust-std-beta-wasm32-unknown-emscripten.tar.gz": "0e268083c1935be97e3a96ca94b824c84877970a65c2e581f3e71d7364264dff", + "dist/2022-08-09/rust-std-beta-wasm32-unknown-emscripten.tar.xz": "27510dbb922d9cc0ee669f3854ffeb1ca28c105b3284e3ba523abcb9cfc10055", + "dist/2022-08-09/rust-std-beta-wasm32-unknown-unknown.tar.gz": "6d2f49e7e75ca2e3873dd1530d4bc3eedcebf3b2db6b1e193c0d57d7daa681a3", + "dist/2022-08-09/rust-std-beta-wasm32-unknown-unknown.tar.xz": "5508d36c7ae20176af2c10a0c974d5162202e3914e79468b9541c3e1b585612a", + "dist/2022-08-09/rust-std-beta-wasm32-wasi.tar.gz": "721726c4b073b27df9abc9e47a2b82eb48ca12a44c87363ae57a632d26619fc9", + "dist/2022-08-09/rust-std-beta-wasm32-wasi.tar.xz": "320ae842da96d4ba3147ca338e91306ed602250320df5163a01748491599ade3", + "dist/2022-08-09/rust-std-beta-x86_64-apple-darwin.tar.gz": "2dd9b9defe95357d7af5ae81428be814efe9923c308a4c2f3a370b16d912707f", + "dist/2022-08-09/rust-std-beta-x86_64-apple-darwin.tar.xz": "17ea6b22feb7fef1211c319a3d9d0f7bcdd8cd215d3ddffc523a83cfeb8331a6", + "dist/2022-08-09/rust-std-beta-x86_64-apple-ios.tar.gz": "df3618fb0b30d89d567d238d4e744d8cff81ca07cef701876b4471a98768c810", + "dist/2022-08-09/rust-std-beta-x86_64-apple-ios.tar.xz": "60932e2848af4a25699e7d300833f0b8e10bc8dc201d4ac9dcda417f86413cb8", + "dist/2022-08-09/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz": "57db93d53efad36639645baf0cdfa47b4b70664e22a1eac3f08a5abedc0834ac", + "dist/2022-08-09/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz": "cea91317cf86ec301730a2ef8a1c68213b6a4921c105bab228e9bd8620641f2b", + "dist/2022-08-09/rust-std-beta-x86_64-fuchsia.tar.gz": "7b961a55c6616b02aa91a25eb9e2521bd50ac881120975ea3af92543adfdd8b5", + "dist/2022-08-09/rust-std-beta-x86_64-fuchsia.tar.xz": "3ce7314f2c8f3a00430a6686fa267a5b4a8ef20b28023b765aa326f0151d2521", + "dist/2022-08-09/rust-std-beta-x86_64-linux-android.tar.gz": "37d538db9ab3cad73c4cdfb0b3836f124a6a2e47dbd1f6aa54167451057ced2f", + "dist/2022-08-09/rust-std-beta-x86_64-linux-android.tar.xz": "600ea7bc318580195d3b4e681c5f374075ec40272641050f0fd6296da4a9d383", + "dist/2022-08-09/rust-std-beta-x86_64-pc-solaris.tar.gz": "7d389f2d2632068cde7e8f72e685a888462897f4d5aa98034060472443cb89ff", + "dist/2022-08-09/rust-std-beta-x86_64-pc-solaris.tar.xz": "60a6532403d902d71883169c2001d6b279f882bee4444bb8107e742e4cfa3ecc", + "dist/2022-08-09/rust-std-beta-x86_64-pc-windows-gnu.tar.gz": "76c93994bc6eaa7596ee91dd24f51685ab659533835d441352f88b89a0991236", + "dist/2022-08-09/rust-std-beta-x86_64-pc-windows-gnu.tar.xz": "fdba628daf4b04afc1ec1d8ac4b9460ffe0a230feaf61dd7b621e2ec02b09a2b", + "dist/2022-08-09/rust-std-beta-x86_64-pc-windows-msvc.tar.gz": "4ee478c238ec38ec4977fa8a1689aa28b7a2b0173549da92f1b2e1a2f6772aee", + "dist/2022-08-09/rust-std-beta-x86_64-pc-windows-msvc.tar.xz": "c732f3054a4a67f25242ba9acb5bfbc945e3ac62a2b0de5b7ede0990313984b5", + "dist/2022-08-09/rust-std-beta-x86_64-sun-solaris.tar.gz": "47a4e8d8cc03e402e480ce5f24326de7094622fe339e4441df7f6a6271a8775c", + "dist/2022-08-09/rust-std-beta-x86_64-sun-solaris.tar.xz": "260c93c4dafb20d476a965e2681751e38be15bfb96d32b10730e44a1d4da6079", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-freebsd.tar.gz": "9d7c63a2ced8041b21459192a0176665ad93324c3774f3028b411eacafd9bfe8", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-freebsd.tar.xz": "276235e7efd773273ffe281cfe5119a9fd361f04ddb1f3ed060d0abb983ff55d", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-illumos.tar.gz": "00ee12a1d47b1d00403e8f2d083a0dbfc8bbbf86ba973b08fbf4c59333f70052", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-illumos.tar.xz": "e11ffdd664228acb94e8e92ae919f7c3bf354083a1ca586be4fa65b7abac17eb", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz": "d58aedd100cf952c52b8364731b1ecc05567c4d6be4899d36f210ff619b934dd", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz": "28021e5a4ff36813f76f6aeb063fefaf58310d65993557df2128ff5b9eeb4f75", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz": "ef5ed09b2bd6b9c1772aeb66444dd821176b4aefb27e657db5bbd24f09d9c104", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz": "c41edbd8ec4266555b7824594eef470ca6d7695675cf13303dcca6b248d0b692", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-linux-musl.tar.gz": "575e5b74248f2503de16294d10e6fec2f6bacac9082ffd73e0395ac2669aefda", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-linux-musl.tar.xz": "4b0f56d6a004c6ebdf325ece1d8006795ffb404ea4f1e958a1425ba9edb28b18", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-netbsd.tar.gz": "9e39545494934be7f91675de58907b7b71fe383c535b55799add8c5706371dcb", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-netbsd.tar.xz": "3807db4641082a329edbd08654f40f769e44d139edc99be0b559c8c00c27adbf", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-none.tar.gz": "4eeddd2654e6a84ef5ad5a6f90d88dab043ca087f884e640c945a4565c6b20e2", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-none.tar.xz": "656e1ff5941fe4699ac16d6c1cdd715fca3a7980b4159644b856af08d8b47918", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-redox.tar.gz": "0e0d5de37c86d6a0684b627f16dd6adebbd2ab4776f4a3fb6a386b3ebe9cdbb2", + "dist/2022-08-09/rust-std-beta-x86_64-unknown-redox.tar.xz": "dc79147efac5730201980035d1ae377cda5a18bb446647e1bc8375c5d645b1c9", + "dist/2022-08-09/rustc-beta-aarch64-apple-darwin.tar.gz": "a3916d7a71d422a0118363228bfcca4a72abd08a6fe6c6d3b4888b87846a1bbf", + "dist/2022-08-09/rustc-beta-aarch64-apple-darwin.tar.xz": "f18d8918c9c1ff55cc513fffa309d72b9aeb853f92dfa66e34fb151a2c374269", + "dist/2022-08-09/rustc-beta-aarch64-pc-windows-msvc.tar.gz": "ba008d21693e01291e3016773f728c98040903eaa6a71abda23f8043eb9348b6", + "dist/2022-08-09/rustc-beta-aarch64-pc-windows-msvc.tar.xz": "1333977a0a147bd5f05eef63ca859b8e78ddc51bed2202616ce5fda5a9203080", + "dist/2022-08-09/rustc-beta-aarch64-unknown-linux-gnu.tar.gz": "78e40c65e40a287e9ee2d9178f84c8ff7277c2a5beff67555185d79fee1af44b", + "dist/2022-08-09/rustc-beta-aarch64-unknown-linux-gnu.tar.xz": "ce24270b141952b3fb67c0f43896416dd77be66ed3b311857bff8b07121e1de9", + "dist/2022-08-09/rustc-beta-aarch64-unknown-linux-musl.tar.gz": "6557c13f5014acda10349a99e24749224b4f86e55b6499e35f05b5e583a1fed3", + "dist/2022-08-09/rustc-beta-aarch64-unknown-linux-musl.tar.xz": "d4b1b814bfa277f895ef4a6c8963ce482965fbdf83ba0661b11db8df39ef301c", + "dist/2022-08-09/rustc-beta-arm-unknown-linux-gnueabi.tar.gz": "3fd9fdfe30333a0a99cf8e9fe754cb1b8f8734b5d1ab47aaf9490d8eaf3b29b8", + "dist/2022-08-09/rustc-beta-arm-unknown-linux-gnueabi.tar.xz": "a736efa35fab54ebf36aebf5c7f5b6d4f0ec1f7b0e5b8b3acf2720d97b0c7d93", + "dist/2022-08-09/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz": "5b824f9aa8a77f8a21d8cf68751924739e65d599c0fe561ea9383b8de4132315", + "dist/2022-08-09/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz": "9996ad84db143044b454483cc24c6ad5c333edd7988ab4ef221237d37891e26d", + "dist/2022-08-09/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz": "6fcbf77721d4d5c51fe5c580f0ff8ac7347d6c49895da33a3eca19e505cc752d", + "dist/2022-08-09/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz": "3b4e566667ee1b2e9fdb5ac6cde4aa3ddf9c9739e7e64e519f2204db2048bd20", + "dist/2022-08-09/rustc-beta-i686-pc-windows-gnu.tar.gz": "cc4f775b79c3ad51bf6ff558267100e05c6fa12ac378d69cc0b0affc37b541a9", + "dist/2022-08-09/rustc-beta-i686-pc-windows-gnu.tar.xz": "b646befe7d3ad1b0a30c9eb4e14a6e401f1346e11f88145ee17043de2b6f4df0", + "dist/2022-08-09/rustc-beta-i686-pc-windows-msvc.tar.gz": "9b4847beb5faf417bc24b4b963f40c8c8dce55b73658eacb10d2d1c968c676b5", + "dist/2022-08-09/rustc-beta-i686-pc-windows-msvc.tar.xz": "6b57826d56686f481d2a20e90994a2af6cb9886c063b1dc08c3bb181ce248a69", + "dist/2022-08-09/rustc-beta-i686-unknown-linux-gnu.tar.gz": "ea34b82db9cc6d079a67df542036c83e8661d435d15802976676671cb2b27c24", + "dist/2022-08-09/rustc-beta-i686-unknown-linux-gnu.tar.xz": "d679a401e807b12fa8fd3686d3ac09374d3c8d660c6f0a571efc7c9217a05f09", + "dist/2022-08-09/rustc-beta-mips-unknown-linux-gnu.tar.gz": "cb3c3638460f3d71c94ca10ab9684ebdbb25f886b8604e62e8412361be56e579", + "dist/2022-08-09/rustc-beta-mips-unknown-linux-gnu.tar.xz": "0665c0e3b2ac28648c2a0ac49670181a737ae30fc74add44a2ee612b1d74dd24", + "dist/2022-08-09/rustc-beta-mips64-unknown-linux-gnuabi64.tar.gz": "0acc722d22b787adbe16549edbf28debdd4d84633701f8bb7514d5911d6ff124", + "dist/2022-08-09/rustc-beta-mips64-unknown-linux-gnuabi64.tar.xz": "441d5ca203afbd5bc4af16431c31d3c76e05edbe45ad37aea4d1f90ca4afecee", + "dist/2022-08-09/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "437c52c97b0a8edd1165b957b768e7c9f7c3d79023626fdcb97538899f424592", + "dist/2022-08-09/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "9812034d2fe8bb583dfe57a792639a6ac7ab912682ad7383db975efd5f0cd281", + "dist/2022-08-09/rustc-beta-mipsel-unknown-linux-gnu.tar.gz": "5d39fe2005a50e40505b18210af700ed8fd439d018fe8723c13221c7683defad", + "dist/2022-08-09/rustc-beta-mipsel-unknown-linux-gnu.tar.xz": "da77cb500618d57682ef4d601e1c8492d9d5412a1833757ffa95d00b0aab790f", + "dist/2022-08-09/rustc-beta-powerpc-unknown-linux-gnu.tar.gz": "5e4559e41c12f1248cec5f4cb40c196e5d6520bffcc043a40759e7a7668ee0b7", + "dist/2022-08-09/rustc-beta-powerpc-unknown-linux-gnu.tar.xz": "41c527f4dbf76275f26f7486b48613fba57171b82275ae29ad90bbe684497ce8", + "dist/2022-08-09/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz": "410f2768e5b69f03ebed37923e0c0bb54d4b297bcbef98d82529216a1dfa4c6f", + "dist/2022-08-09/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz": "7f0d0ff4a797120c1a31d33cecd4abd4bd69ec6ff97351291267423f27f7f3f1", + "dist/2022-08-09/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz": "2fa446a7f79d254350b7e9828a36fd415f6931494bdec8bf8f26e0c13636849f", + "dist/2022-08-09/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz": "8572718b7ca5aef0de8227550816dbbd7b41fcc2ab6b0624a50096fa387503ce", + "dist/2022-08-09/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz": "7d82792f2526c6e6522c5255dd350e09f838551f743f760634b875eb22b48b0e", + "dist/2022-08-09/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz": "99f4ff1b50ce3b644b12bc0da84910f376c9187adede0222dc8a1e242e347263", + "dist/2022-08-09/rustc-beta-s390x-unknown-linux-gnu.tar.gz": "81f32e172bc635028fe048d2194f1d49c4f31b4daadf8690931cd3a15a9e06d1", + "dist/2022-08-09/rustc-beta-s390x-unknown-linux-gnu.tar.xz": "c50258bda8d09646bef493463d66be02d8e7155122e2b7eafe9bc5bd11cbe6b9", + "dist/2022-08-09/rustc-beta-x86_64-apple-darwin.tar.gz": "fa2d6a74109c087f13fbbf00171252fcd9079b9978028ee6df4fb2d18c27a39e", + "dist/2022-08-09/rustc-beta-x86_64-apple-darwin.tar.xz": "630b218549ee04a8bc5a8a29616d5d8c1d866804cedb2fc3861cc2e354382c5e", + "dist/2022-08-09/rustc-beta-x86_64-pc-windows-gnu.tar.gz": "633b22f9c9a93f6cbed7a53fb466ea0bf5895f6fa9c3a22a5883951cedbd606b", + "dist/2022-08-09/rustc-beta-x86_64-pc-windows-gnu.tar.xz": "d109d67480ab01ab1e176b5c904df5053fbb54baaf422d4f5019a28dd122e149", + "dist/2022-08-09/rustc-beta-x86_64-pc-windows-msvc.tar.gz": "627635dcd8515ed029515e1621b8411e1a3a6ede4058d2cf581c8d669b96dd5f", + "dist/2022-08-09/rustc-beta-x86_64-pc-windows-msvc.tar.xz": "6f98febabe7229c566c86728dcf773849c97f29bc0f43ea4f5ffb4e81f163b18", + "dist/2022-08-09/rustc-beta-x86_64-unknown-freebsd.tar.gz": "a4b4dcd9dd1128df37d761efaa669ebb35841af0847b5bb5bcf38295ca47db6d", + "dist/2022-08-09/rustc-beta-x86_64-unknown-freebsd.tar.xz": "cd28418166eaa754102b469414d0fcfe6785096855e50a2b895c5903e528d8c2", + "dist/2022-08-09/rustc-beta-x86_64-unknown-illumos.tar.gz": "168cf42f579132b44ac35a214328f518ab201d6fb9d88d645899fdd88e1d5e34", + "dist/2022-08-09/rustc-beta-x86_64-unknown-illumos.tar.xz": "7792763eda89f90a878b09dd99ea9af94d6db0c36bb9570e9b1a05d8dc2f1e47", + "dist/2022-08-09/rustc-beta-x86_64-unknown-linux-gnu.tar.gz": "ec79355625df63a29487253925f5213442f8606f2fd6fca7a94f8db57220f802", + "dist/2022-08-09/rustc-beta-x86_64-unknown-linux-gnu.tar.xz": "b7df0b00cfc3bee9a1a906441726ae009aa7dfbfe22e16bc9127ec4df11cd1a7", + "dist/2022-08-09/rustc-beta-x86_64-unknown-linux-musl.tar.gz": "372a7c389366e543f3477f2854271c7a74042abf51c37f2d5ce1450f4cd3bfd3", + "dist/2022-08-09/rustc-beta-x86_64-unknown-linux-musl.tar.xz": "11243da1c7642ee7ece1b43de1e59b4c45fa8ecf0c9d632d6f1db4772e4479a6", + "dist/2022-08-09/rustc-beta-x86_64-unknown-netbsd.tar.gz": "808a451394f4a023ef28420d7dc29e2de92618e5a563055798ec2307e0ca062f", + "dist/2022-08-09/rustc-beta-x86_64-unknown-netbsd.tar.xz": "55b447374eb361b2ea1de87080bac3a0cc4fbd233e916e53e5424d6b9ed0dc48", + "dist/2022-08-09/rustfmt-nightly-aarch64-apple-darwin.tar.gz": "bbbfd82986d5fafa76f06b87b08cfda800dbc87a1adaed3587f570336a648c3f", + "dist/2022-08-09/rustfmt-nightly-aarch64-apple-darwin.tar.xz": "69a99ec973a3603c3d84361d407fbe9c79af0a284a48f5578fb6f46affe751b1", + "dist/2022-08-09/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz": "4a886c744cd6b5f4fe0ec2a3b87730e9a4f7a66c9d4fb0c6411be32014e9e5f0", + "dist/2022-08-09/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz": "095ff2687c8dd48decf47c2b65ce84579bc753de0732877cb092b4ccb9df4f92", + "dist/2022-08-09/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz": "3533a40f72ee318f04448f005e0a811add2e97285e158f63758f76b4424ebe46", + "dist/2022-08-09/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz": "85a4f34d889bf52b65b93066bd1bd6a91092ed49cf6443f476bd60fb36b1cb6d", + "dist/2022-08-09/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz": "11c4bb5a071d555cda8b685e340727eb588f7a830cd4fc22937e44e68b3d7ee4", + "dist/2022-08-09/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz": "b7c9628299f155530d5a2831a4ffe8d398d2cd222952815006eb19d6ff92a846", + "dist/2022-08-09/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz": "04ce1aec5cd9c7ba644954d8ec6ba4c851de1c964b64b0d63965cd2043e7d590", + "dist/2022-08-09/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz": "08635b48b6a7585dbeb7e53f5aac172404e8dfbdf8c165e281064737f073a013", + "dist/2022-08-09/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz": "852ea71bee89cbf9c9fd1d9abb02a88695732d51b106d3de78c36f371663341e", + "dist/2022-08-09/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz": "499ded5cd2689626186c3a51af671991ec67ea0eb16bfa30097a764c6718405a", + "dist/2022-08-09/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz": "eff28bbdd1d3dc44fb4504b24856dc8c550f1311ce56a1614acf2b7409a1c5e2", + "dist/2022-08-09/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz": "b621a87a5257c280b0610fa90abd288264ee01238669d61030ae057e87eb8e47", + "dist/2022-08-09/rustfmt-nightly-i686-pc-windows-gnu.tar.gz": "9307f1feb9c06f57930cd0009aa7b740f1c9e1515212bd7e2ae81149ea0f571d", + "dist/2022-08-09/rustfmt-nightly-i686-pc-windows-gnu.tar.xz": "fea653c9e14d305ed217f9c984742c066ea7f7d2fb6d316a13586afc820fca8a", + "dist/2022-08-09/rustfmt-nightly-i686-pc-windows-msvc.tar.gz": "8e600a6ad04dff36fe9b1846592faa693b1a036f58d136a522d6ca86f9d76be1", + "dist/2022-08-09/rustfmt-nightly-i686-pc-windows-msvc.tar.xz": "52b45791540bc754a82a7349ca4c5ce194afd28e6c857b61f0ff7e87f10f1253", + "dist/2022-08-09/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz": "964847cfa824c66db554ec20a7e623f4ea50e4cef2439b6813592bcdc31a94ce", + "dist/2022-08-09/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz": "71b89b63be5a44e12d0303e71e3e14b0b770aaac5bcf2879e17526b27e568c6d", + "dist/2022-08-09/rustfmt-nightly-mips-unknown-linux-gnu.tar.gz": "aac0b10cfcb07c64de04fea33d9cf8d691f307e3aefaa9582a8ba3e1fd54aa35", + "dist/2022-08-09/rustfmt-nightly-mips-unknown-linux-gnu.tar.xz": "e3688bc8ef82fff7685cc95fc1ec708a5d76d288cccbd42c37e5c83184f6a52e", + "dist/2022-08-09/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.gz": "aa89a2dbfe0c6020139d8be52be126a01af9691eaf73fa94c94f9ae75d09d619", + "dist/2022-08-09/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.xz": "1e7e5f11f829b06f4d8ae5b6d38f13e055ff1fda5b1481e33e40e2a336c7852a", + "dist/2022-08-09/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.gz": "e43b8009179139c1bd15f3e947a8bc7357e57833959f9fd18fde1d75a742bede", + "dist/2022-08-09/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.xz": "5bf84aa3ad0badbf0c60d31f686498801d9a23dc0324062128cd7690f9c69234", + "dist/2022-08-09/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.gz": "b3816072c441ee9e2b8da5cc6a8ed022795b7176d4ac604d97b0d213f89522ac", + "dist/2022-08-09/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.xz": "d7c6b668f4a2c128ab845e010deb7c9c3e374aaf167244395cdad6c746f73420", + "dist/2022-08-09/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz": "91c36676f8b9093976d7e30ac39f2c477f8442771a3e9c49f41610a0b8688cbe", + "dist/2022-08-09/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz": "86bc5289beee0abf87bfc57a09d6504bfe58675871f4e7559b7f9e1b748e8dc6", + "dist/2022-08-09/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz": "12a1716934b48c2cf716a56c66f95852a70bc74b65c2e44a542b9c2ebf1be5ec", + "dist/2022-08-09/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz": "591ac7d4acd0036d532c91fa3f64a7789881224dd5496b1fe3564c79fd5f0254", + "dist/2022-08-09/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz": "b558c9463e5b8380e133a7a64bc95994d8625fa0097f8b41fb39c93367704698", + "dist/2022-08-09/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz": "d28bbc411779d19279fec251e9378b3923c4b3a8c651d375e139732dd6daaaad", + "dist/2022-08-09/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz": "af9644ab1e369495a4e35fbd111946c679e597c8c1f8342d3a92bad0cad30ffc", + "dist/2022-08-09/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz": "c2acdb98f2c2565cbaf57557cbd99038fb066a09b5602ff3d3bbcb58388b4501", + "dist/2022-08-09/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz": "eddd4a32740ba700c095568bff791e959d6b8ab0a47b5e98a317ea56cc754751", + "dist/2022-08-09/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz": "021bba582076650b577d78fda0b6d9374b17e623d2f3ddb0322f9960874ac269", + "dist/2022-08-09/rustfmt-nightly-x86_64-apple-darwin.tar.gz": "355c877020b386f0297765f8ae1b1e3fa126c9e9b537f8923d275bd31cbdba33", + "dist/2022-08-09/rustfmt-nightly-x86_64-apple-darwin.tar.xz": "809d3314e1b69efb5544fa6daa6719907e09edfd7e0c2cf483ad89a3d508b98d", + "dist/2022-08-09/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz": "def326ede8106aa440b57698a027fffe024158351879d17f9bba0e58c3788662", + "dist/2022-08-09/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz": "86684f3c6ba66216c5c9cb203eb9fce96e0239a345df912a2071bc9aa83cc9da", + "dist/2022-08-09/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz": "2d658db4849089e86af76eb4d7986d605da644af6f6ad43429931f775b5bb094", + "dist/2022-08-09/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz": "ec14c63680836e5303450d3bfda7b6ca5b163ec01cdaf1e3f2d7b6c584c4c6a1", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz": "39542f4fd6261b864c59494958071dacd32703fd870286ec5fceaf3664d3e5a4", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz": "a02061c8bcdd23a8b3f21c4f776e900536fcd44019a495fdec159fd9b4282700", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-illumos.tar.gz": "15fe16aca96080380c6ebf109522f60134dbaad610d3841e07ac5059ee920edc", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-illumos.tar.xz": "43d562bce508ccc40afdc3f1ec85b6f0e29b1bad1661a758d07e57cb97d63407", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz": "80659ef19b274724eb3becb90ca03ea6cb6eb1ff9ff6989073df6e1e52c0d406", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz": "392e98288ea2ef6602dff922c9bef4fcb17acdcefbb4bca050ede73aeee669e8", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz": "1eccdcb7cdb96ffb5a5261d4190e4bd1f92e5cf61e92e556ed6baf42e9c316ab", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz": "9526d26c9fef619cf429437d45c5a79e89a894b22f88635d7995639f1f9696b6", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz": "486b79d19fff869275f973b274b3cddf02693ba444a79a2e100c6ba79be5d493", + "dist/2022-08-09/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz": "1378376c8b16aa269034cd99b2efb8d8a0fe77e9526338d652b6d6e9aff2ac0c" } } diff --git a/src/test/run-make/translation/Makefile b/src/test/run-make/translation/Makefile index bfff75e7acb..20e86c7f9a0 100644 --- a/src/test/run-make/translation/Makefile +++ b/src/test/run-make/translation/Makefile @@ -9,16 +9,29 @@ FAKEROOT=$(TMPDIR)/fakeroot all: normal custom sysroot -normal: basic-translation.rs +# Check that the test works normally, using the built-in fallback bundle. +normal: test.rs $(RUSTC) $< 2>&1 | grep "struct literal body without path" -custom: basic-translation.rs basic-translation.ftl - $(RUSTC) $< -Ztranslate-additional-ftl=$(CURDIR)/basic-translation.ftl 2>&1 | grep "this is a test message" +# Check that a primary bundle can be loaded and will be preferentially used +# where possible. +custom: test.rs working.ftl + $(RUSTC) $< -Ztranslate-additional-ftl=$(CURDIR)/working.ftl 2>&1 | grep "this is a test message" + +# Check that a primary bundle with a broken message (e.g. a interpolated +# variable is missing) will use the fallback bundle. +missing: test.rs missing.ftl + $(RUSTC) $< -Ztranslate-additional-ftl=$(CURDIR)/missing.ftl 2>&1 | grep "struct literal body without path" + +# Check that a primary bundle without the desired message will use the fallback +# bundle. +broken: test.rs broken.ftl + $(RUSTC) $< -Ztranslate-additional-ftl=$(CURDIR)/broken.ftl 2>&1 | grep "struct literal body without path" # Check that a locale can be loaded from the sysroot given a language # identifier by making a local copy of the sysroot and adding the custom locale # to it. -sysroot: basic-translation.rs basic-translation.ftl +sysroot: test.rs working.ftl mkdir $(FAKEROOT) ln -s $(SYSROOT)/* $(FAKEROOT) rm -f $(FAKEROOT)/lib @@ -31,7 +44,7 @@ sysroot: basic-translation.rs basic-translation.ftl mkdir $(FAKEROOT)/lib/rustlib/src ln -s $(SYSROOT)/lib/rustlib/src/* $(FAKEROOT)/lib/rustlib/src mkdir -p $(FAKEROOT)/share/locale/zh-CN/ - ln -s $(CURDIR)/basic-translation.ftl $(FAKEROOT)/share/locale/zh-CN/basic-translation.ftl + ln -s $(CURDIR)/working.ftl $(FAKEROOT)/share/locale/zh-CN/basic-translation.ftl $(RUSTC) $< --sysroot $(FAKEROOT) -Ztranslate-lang=zh-CN 2>&1 | grep "this is a test message" # Check that the compiler errors out when the sysroot requested cannot be @@ -43,7 +56,7 @@ sysroot-missing: # Check that the compiler errors out when the sysroot requested cannot be # found. This test might start failing if there actually exists a Klingon # translation of rustc's error messages. -sysroot-invalid: basic-translation.rs basic-translation.ftl +sysroot-invalid: test.rs working.ftl mkdir $(FAKEROOT) ln -s $(SYSROOT)/* $(FAKEROOT) rm -f $(FAKEROOT)/lib diff --git a/src/test/run-make/translation/broken.ftl b/src/test/run-make/translation/broken.ftl new file mode 100644 index 00000000000..1482dd2824a --- /dev/null +++ b/src/test/run-make/translation/broken.ftl @@ -0,0 +1,3 @@ +# `foo` isn't provided by this diagnostic so it is expected that the fallback message is used. +parser-struct-literal-body-without-path = this is a {$foo} message + .suggestion = this is a test suggestion diff --git a/src/test/run-make/translation/missing.ftl b/src/test/run-make/translation/missing.ftl new file mode 100644 index 00000000000..43076b1d6ae --- /dev/null +++ b/src/test/run-make/translation/missing.ftl @@ -0,0 +1,3 @@ +# `parser-struct-literal-body-without-path` isn't provided by this resource at all, so the +# fallback should be used. +foo = bar diff --git a/src/test/run-make/translation/basic-translation.rs b/src/test/run-make/translation/test.rs index b8f5bff3153..b8f5bff3153 100644 --- a/src/test/run-make/translation/basic-translation.rs +++ b/src/test/run-make/translation/test.rs diff --git a/src/test/run-make/translation/basic-translation.ftl b/src/test/run-make/translation/working.ftl index 4681b879cda..4681b879cda 100644 --- a/src/test/run-make/translation/basic-translation.ftl +++ b/src/test/run-make/translation/working.ftl diff --git a/src/test/rustdoc-json/fns/generic_args.rs b/src/test/rustdoc-json/fns/generic_args.rs index 69150443c29..98ba8e99d82 100644 --- a/src/test/rustdoc-json/fns/generic_args.rs +++ b/src/test/rustdoc-json/fns/generic_args.rs @@ -14,7 +14,7 @@ pub trait GenericFoo<'a> {} // @is - "$.index[*][?(@.name=='generics')].inner.generics.params[0].name" '"F"' // @is - "$.index[*][?(@.name=='generics')].inner.generics.params[0].kind.type.default" 'null' // @count - "$.index[*][?(@.name=='generics')].inner.generics.params[0].kind.type.bounds[*]" 1 -// @is - "$.index[*][?(@.name=='generics')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" '$foo' +// @is - "$.index[*][?(@.name=='generics')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.id" '$foo' // @count - "$.index[*][?(@.name=='generics')].inner.decl.inputs[*]" 1 // @is - "$.index[*][?(@.name=='generics')].inner.decl.inputs[0][0]" '"f"' // @is - "$.index[*][?(@.name=='generics')].inner.decl.inputs[0][1].kind" '"generic"' @@ -24,12 +24,12 @@ pub fn generics<F: Foo>(f: F) {} // @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.where_predicates" "[]" // @count - "$.index[*][?(@.name=='impl_trait')].inner.generics.params[*]" 1 // @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.params[0].name" '"impl Foo"' -// @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" $foo +// @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.id" $foo // @count - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[*]" 1 // @is - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][0]" '"f"' // @is - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][1].kind" '"impl_trait"' // @count - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][1].inner[*]" 1 -// @is - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][1].inner[0].trait_bound.trait.inner.id" $foo +// @is - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][1].inner[0].trait_bound.trait.id" $foo pub fn impl_trait(f: impl Foo) {} // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.params[*]" 3 @@ -43,11 +43,11 @@ pub fn impl_trait(f: impl Foo) {} // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[0].bound_predicate.type" '{"inner": "F", "kind": "generic"}' // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[0].bound_predicate.bounds[*]" 1 -// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[0].bound_predicate.bounds[0].trait_bound.trait.inner.id" $foo +// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[0].bound_predicate.bounds[0].trait_bound.trait.id" $foo // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.type" '{"inner": "G", "kind": "generic"}' // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[*]" 1 -// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.trait.inner.id" $generic_foo +// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.trait.id" $generic_foo // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.generic_params[*]" 1 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.generic_params[0].name" \"\'a\" // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.generic_params[0].kind" '{ "lifetime": { "outlives": [] } }' @@ -57,7 +57,7 @@ pub fn impl_trait(f: impl Foo) {} // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.type.inner.lifetime" \"\'b\" // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.type.inner.type" '{"inner": "H", "kind": "generic"}' // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.bounds[*]" 1 -// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.bounds[0].trait_bound.trait.inner.id" $foo +// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.bounds[0].trait_bound.trait.id" $foo // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.bounds[0].trait_bound.generic_params" "[]" // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.generic_params[*]" 1 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.generic_params[0].name" \"\'b\" diff --git a/src/test/rustdoc-json/fns/generic_returns.rs b/src/test/rustdoc-json/fns/generic_returns.rs index 1a0f33fe3d2..46f250a99b9 100644 --- a/src/test/rustdoc-json/fns/generic_returns.rs +++ b/src/test/rustdoc-json/fns/generic_returns.rs @@ -11,7 +11,7 @@ pub trait Foo {} // @is - "$.index[*][?(@.name=='get_foo')].inner.decl.inputs" [] // @is - "$.index[*][?(@.name=='get_foo')].inner.decl.output.kind" '"impl_trait"' // @count - "$.index[*][?(@.name=='get_foo')].inner.decl.output.inner[*]" 1 -// @is - "$.index[*][?(@.name=='get_foo')].inner.decl.output.inner[0].trait_bound.trait.inner.id" $foo +// @is - "$.index[*][?(@.name=='get_foo')].inner.decl.output.inner[0].trait_bound.trait.id" $foo pub fn get_foo() -> impl Foo { Fooer {} } diff --git a/src/test/rustdoc-json/fns/generics.rs b/src/test/rustdoc-json/fns/generics.rs index e777fabaa52..e55e1e9400d 100644 --- a/src/test/rustdoc-json/fns/generics.rs +++ b/src/test/rustdoc-json/fns/generics.rs @@ -10,7 +10,7 @@ pub trait Wham {} // @count - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[*]" 1 // @is - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[0].name" '"T"' // @has - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[0].kind.type.synthetic" false -// @has - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" $wham_id +// @has - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.id" $wham_id // @is - "$.index[*][?(@.name=='one_generic_param_fn')].inner.decl.inputs" '[["w", {"inner": "T", "kind": "generic"}]]' pub fn one_generic_param_fn<T: Wham>(w: T) {} @@ -18,9 +18,9 @@ pub fn one_generic_param_fn<T: Wham>(w: T) {} // @count - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[*]" 1 // @is - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[0].name" '"impl Wham"' // @has - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[0].kind.type.synthetic" true -// @has - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" $wham_id +// @has - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.id" $wham_id // @count - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[*]" 1 // @is - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[0][0]" '"w"' // @is - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[0][1].kind" '"impl_trait"' -// @is - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[0][1].inner[0].trait_bound.trait.inner.id" $wham_id +// @is - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[0][1].inner[0].trait_bound.trait.id" $wham_id pub fn one_synthetic_generic_param_fn(w: impl Wham) {} diff --git a/src/test/rustdoc-json/impls/auto.rs b/src/test/rustdoc-json/impls/auto.rs new file mode 100644 index 00000000000..fb32d7c31bc --- /dev/null +++ b/src/test/rustdoc-json/impls/auto.rs @@ -0,0 +1,18 @@ +#![feature(no_core, auto_traits, lang_items)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +pub auto trait Bar {} + +/// has span +impl Foo { + pub fn baz(&self) {} +} + +// Testing spans, so all tests below code +// @is auto.json "$.index[*][?(@.kind=='impl' && @.inner.synthetic==true)].span" null +// @is - "$.index[*][?(@.docs=='has span')].span.begin" "[10, 0]" +// @is - "$.index[*][?(@.docs=='has span')].span.end" "[12, 1]" +pub struct Foo; diff --git a/src/test/rustdoc-json/traits/supertrait.rs b/src/test/rustdoc-json/traits/supertrait.rs index 486a8e713f8..ce2f3912ba6 100644 --- a/src/test/rustdoc-json/traits/supertrait.rs +++ b/src/test/rustdoc-json/traits/supertrait.rs @@ -9,18 +9,18 @@ pub trait Loud {} // @set very_loud_id = - "$.index[*][?(@.name=='VeryLoud')].id" // @count - "$.index[*][?(@.name=='VeryLoud')].inner.bounds[*]" 1 -// @is - "$.index[*][?(@.name=='VeryLoud')].inner.bounds[0].trait_bound.trait.inner.id" $loud_id +// @is - "$.index[*][?(@.name=='VeryLoud')].inner.bounds[0].trait_bound.trait.id" $loud_id pub trait VeryLoud: Loud {} // @set sounds_good_id = - "$.index[*][?(@.name=='SoundsGood')].id" pub trait SoundsGood {} // @count - "$.index[*][?(@.name=='MetalBand')].inner.bounds[*]" 2 -// @is - "$.index[*][?(@.name=='MetalBand')].inner.bounds[0].trait_bound.trait.inner.id" $very_loud_id -// @is - "$.index[*][?(@.name=='MetalBand')].inner.bounds[1].trait_bound.trait.inner.id" $sounds_good_id +// @is - "$.index[*][?(@.name=='MetalBand')].inner.bounds[0].trait_bound.trait.id" $very_loud_id +// @is - "$.index[*][?(@.name=='MetalBand')].inner.bounds[1].trait_bound.trait.id" $sounds_good_id pub trait MetalBand: VeryLoud + SoundsGood {} // @count - "$.index[*][?(@.name=='DnabLatem')].inner.bounds[*]" 2 -// @is - "$.index[*][?(@.name=='DnabLatem')].inner.bounds[1].trait_bound.trait.inner.id" $very_loud_id -// @is - "$.index[*][?(@.name=='DnabLatem')].inner.bounds[0].trait_bound.trait.inner.id" $sounds_good_id +// @is - "$.index[*][?(@.name=='DnabLatem')].inner.bounds[1].trait_bound.trait.id" $very_loud_id +// @is - "$.index[*][?(@.name=='DnabLatem')].inner.bounds[0].trait_bound.trait.id" $sounds_good_id pub trait DnabLatem: SoundsGood + VeryLoud {} diff --git a/src/test/rustdoc-json/type/dyn.rs b/src/test/rustdoc-json/type/dyn.rs index c18b54d1fdf..690dccc8287 100644 --- a/src/test/rustdoc-json/type/dyn.rs +++ b/src/test/rustdoc-json/type/dyn.rs @@ -21,10 +21,10 @@ use std::fmt::Debug; // @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[0].generic_params" [] // @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[1].generic_params" [] // @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[2].generic_params" [] -// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[0].trait.inner.name" '"Fn"' -// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[1].trait.inner.name" '"Send"' -// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[2].trait.inner.name" '"Sync"' -// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[0].trait.inner.args" '{"parenthesized": {"inputs": [],"output": {"inner": "i32","kind": "primitive"}}}' +// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[0].trait.name" '"Fn"' +// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[1].trait.name" '"Send"' +// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[2].trait.name" '"Sync"' +// @is - "$.index[*][?(@.name=='SyncIntGen')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[0].trait.args" '{"parenthesized": {"inputs": [],"output": {"inner": "i32","kind": "primitive"}}}' pub type SyncIntGen = Box<dyn Fn() -> i32 + Send + Sync + 'static>; // @is - "$.index[*][?(@.name=='RefFn')].kind" \"typedef\" @@ -36,14 +36,13 @@ pub type SyncIntGen = Box<dyn Fn() -> i32 + Send + Sync + 'static>; // @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.lifetime" null // @count - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[*]" 1 // @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].generic_params" '[{"kind": {"lifetime": {"outlives": []}},"name": "'\''b"}]' -// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.kind" '"resolved_path"' -// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.inner.name" '"Fn"' -// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.inner.args.parenthesized.inputs[0].kind" '"borrowed_ref"' -// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.inner.args.parenthesized.inputs[0].inner.lifetime" "\"'b\"" -// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.inner.args.parenthesized.output.kind" '"borrowed_ref"' -// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.inner.args.parenthesized.output.inner.lifetime" "\"'b\"" +// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.name" '"Fn"' +// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.args.parenthesized.inputs[0].kind" '"borrowed_ref"' +// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.args.parenthesized.inputs[0].inner.lifetime" "\"'b\"" +// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.args.parenthesized.output.kind" '"borrowed_ref"' +// @is - "$.index[*][?(@.name=='RefFn')].inner.type.inner.type.inner.traits[0].trait.args.parenthesized.output.inner.lifetime" "\"'b\"" pub type RefFn<'a> = &'a dyn for<'b> Fn(&'b i32) -> &'b i32; -// @is - "$.index[*][?(@.name=='WeirdOrder')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[0].trait.inner.name" '"Send"' -// @is - "$.index[*][?(@.name=='WeirdOrder')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[1].trait.inner.name" '"Debug"' +// @is - "$.index[*][?(@.name=='WeirdOrder')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[0].trait.name" '"Send"' +// @is - "$.index[*][?(@.name=='WeirdOrder')].inner.type.inner.args.angle_bracketed.args[0].type.inner.traits[1].trait.name" '"Debug"' pub type WeirdOrder = Box<dyn Send + Debug>; diff --git a/src/test/rustdoc-json/type/hrtb.rs b/src/test/rustdoc-json/type/hrtb.rs index 9311737be0f..5b0c4caee21 100644 --- a/src/test/rustdoc-json/type/hrtb.rs +++ b/src/test/rustdoc-json/type/hrtb.rs @@ -19,7 +19,7 @@ where // @is - "$.index[*][?(@.name=='dynfn')].inner.decl.inputs[0][1].inner.type.inner.lifetime" null // @count - "$.index[*][?(@.name=='dynfn')].inner.decl.inputs[0][1].inner.type.inner.traits[*]" 1 // @is - "$.index[*][?(@.name=='dynfn')].inner.decl.inputs[0][1].inner.type.inner.traits[0].generic_params" '[{"kind": {"lifetime": {"outlives": []}},"name": "'\''a"},{"kind": {"lifetime": {"outlives": []}},"name": "'\''b"}]' -// @is - "$.index[*][?(@.name=='dynfn')].inner.decl.inputs[0][1].inner.type.inner.traits[0].trait.inner.name" '"Fn"' +// @is - "$.index[*][?(@.name=='dynfn')].inner.decl.inputs[0][1].inner.type.inner.traits[0].trait.name" '"Fn"' pub fn dynfn(f: &dyn for<'a, 'b> Fn(&'a i32, &'b i32)) { let zero = 0; f(&zero, &zero); diff --git a/src/test/rustdoc-ui/z-help.stdout b/src/test/rustdoc-ui/z-help.stdout index 6dc41231559..236469ce979 100644 --- a/src/test/rustdoc-ui/z-help.stdout +++ b/src/test/rustdoc-ui/z-help.stdout @@ -38,6 +38,7 @@ -Z emit-stack-sizes=val -- emit a section containing stack size metadata (default: no) -Z emit-thin-lto=val -- emit the bc module with thin LTO info (default: yes) -Z export-executable-symbols=val -- export symbols from executables, as if they were dynamic libraries + -Z extra-const-ub-checks=val -- turns on more checks to detect const UB, which can be slow (default: no) -Z fewer-names=val -- reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) (default: no) -Z force-unstable-if-unmarked=val -- force all crates to be `rustc_private` unstable (default: no) -Z fuel=val -- set the optimization fuel quota for a crate diff --git a/src/test/rustdoc/all.rs b/src/test/rustdoc/all.rs index a95d6c46206..4c8d0231095 100644 --- a/src/test/rustdoc/all.rs +++ b/src/test/rustdoc/all.rs @@ -24,5 +24,5 @@ mod private_module { } // @has foo/all.html '//a[@href="struct.ReexportedStruct.html"]' 'ReexportedStruct' -// @!has foo/all.html 'private_module' +// @!hasraw foo/all.html 'private_module' pub use private_module::ReexportedStruct; diff --git a/src/test/rustdoc/assoc-consts.rs b/src/test/rustdoc/assoc-consts.rs index a79e93145ba..97b7739b4c9 100644 --- a/src/test/rustdoc/assoc-consts.rs +++ b/src/test/rustdoc/assoc-consts.rs @@ -5,7 +5,7 @@ pub trait Foo { const FOO: usize = 12 + 1; // @has - '//*[@id="associatedconstant.FOO_NO_DEFAULT"]' 'const FOO_NO_DEFAULT: bool' const FOO_NO_DEFAULT: bool; - // @!has - FOO_HIDDEN + // @!hasraw - FOO_HIDDEN #[doc(hidden)] const FOO_HIDDEN: u8 = 0; } @@ -18,7 +18,7 @@ impl Foo for Bar { const FOO: usize = 12; // @has - '//*[@id="associatedconstant.FOO_NO_DEFAULT"]' 'const FOO_NO_DEFAULT: bool' const FOO_NO_DEFAULT: bool = false; - // @!has - FOO_HIDDEN + // @!hasraw - FOO_HIDDEN #[doc(hidden)] const FOO_HIDDEN: u8 = 0; } @@ -50,9 +50,9 @@ impl Bar { } impl Bar { - // @!has assoc_consts/struct.Bar.html 'BAR_PRIVATE' + // @!hasraw assoc_consts/struct.Bar.html 'BAR_PRIVATE' const BAR_PRIVATE: char = 'a'; - // @!has assoc_consts/struct.Bar.html 'BAR_HIDDEN' + // @!hasraw assoc_consts/struct.Bar.html 'BAR_HIDDEN' #[doc(hidden)] pub const BAR_HIDDEN: &'static str = "a"; } diff --git a/src/test/rustdoc/const-display.rs b/src/test/rustdoc/const-display.rs index 8455dd9ef95..594501b22b1 100644 --- a/src/test/rustdoc/const-display.rs +++ b/src/test/rustdoc/const-display.rs @@ -20,7 +20,7 @@ pub const fn foo() -> u32 { 42 } pub const unsafe fn foo_unsafe() -> u32 { 42 } // @has 'foo/fn.foo2.html' '//pre' 'pub const fn foo2() -> u32' -// @!has - '//span[@class="since"]' +// @!hasraw - '//span[@class="since"]' #[unstable(feature = "humans", issue = "none")] pub const fn foo2() -> u32 { 42 } @@ -32,7 +32,7 @@ pub const fn bar2() -> u32 { 42 } // @has 'foo/fn.foo2_gated.html' '//pre' 'pub const unsafe fn foo2_gated() -> u32' -// @!has - '//span[@class="since"]' +// @!hasraw - '//span[@class="since"]' #[unstable(feature = "foo2", issue = "none")] pub const unsafe fn foo2_gated() -> u32 { 42 } @@ -43,7 +43,7 @@ pub const unsafe fn foo2_gated() -> u32 { 42 } pub const unsafe fn bar2_gated() -> u32 { 42 } // @has 'foo/fn.bar_not_gated.html' '//pre' 'pub const unsafe fn bar_not_gated() -> u32' -// @!has - '//span[@class="since"]' +// @!hasraw - '//span[@class="since"]' pub const unsafe fn bar_not_gated() -> u32 { 42 } pub struct Foo; diff --git a/src/test/rustdoc/deprecated-impls.rs b/src/test/rustdoc/deprecated-impls.rs index efd250ce9f0..e419d2631f6 100644 --- a/src/test/rustdoc/deprecated-impls.rs +++ b/src/test/rustdoc/deprecated-impls.rs @@ -5,8 +5,8 @@ pub struct Foo0; impl Foo0 { // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.1: fn_with_doc' - // @has - 'fn_with_doc short' - // @has - 'fn_with_doc full' + // @hasraw - 'fn_with_doc short' + // @hasraw - 'fn_with_doc full' /// fn_with_doc short /// /// fn_with_doc full @@ -52,8 +52,8 @@ pub struct Foo1; impl Bar for Foo1 { // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.3: fn_empty_with_doc' - // @has - 'fn_empty_with_doc_impl short' - // @has - 'fn_empty_with_doc_impl full' + // @hasraw - 'fn_empty_with_doc_impl short' + // @hasraw - 'fn_empty_with_doc_impl full' /// fn_empty_with_doc_impl short /// /// fn_empty_with_doc_impl full @@ -63,8 +63,8 @@ impl Bar for Foo1 { fn fn_empty_without_doc() {} // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.5: fn_def_with_doc' - // @has - 'fn_def_with_doc_impl short' - // @has - 'fn_def_with_doc_impl full' + // @hasraw - 'fn_def_with_doc_impl short' + // @hasraw - 'fn_def_with_doc_impl full' /// fn_def_with_doc_impl short /// /// fn_def_with_doc_impl full @@ -74,8 +74,8 @@ impl Bar for Foo1 { fn fn_def_without_doc() {} // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.7: fn_def_def_with_doc' - // @has - 'fn_def_def_with_doc short' - // @!has - 'fn_def_def_with_doc full' + // @hasraw - 'fn_def_def_with_doc short' + // @!hasraw - 'fn_def_def_with_doc full' // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.8: fn_def_def_without_doc' } @@ -85,34 +85,34 @@ pub struct Foo2; impl Bar for Foo2 { // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.3: fn_empty_with_doc' - // @has - 'fn_empty_with_doc short' - // @!has - 'fn_empty_with_doc full' + // @hasraw - 'fn_empty_with_doc short' + // @!hasraw - 'fn_empty_with_doc full' fn fn_empty_with_doc() {} // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.4: fn_empty_without_doc' - // @has - 'fn_empty_without_doc_impl short' - // @has - 'fn_empty_without_doc_impl full' + // @hasraw - 'fn_empty_without_doc_impl short' + // @hasraw - 'fn_empty_without_doc_impl full' /// fn_empty_without_doc_impl short /// /// fn_empty_without_doc_impl full fn fn_empty_without_doc() {} // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.5: fn_def_with_doc' - // @has - 'fn_def_with_doc short' - // @!has - 'fn_def_with_doc full' + // @hasraw - 'fn_def_with_doc short' + // @!hasraw - 'fn_def_with_doc full' fn fn_def_with_doc() {} // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.6: fn_def_without_doc' - // @has - 'fn_def_without_doc_impl short' - // @has - 'fn_def_without_doc_impl full' + // @hasraw - 'fn_def_without_doc_impl short' + // @hasraw - 'fn_def_without_doc_impl full' /// fn_def_without_doc_impl short /// /// fn_def_without_doc_impl full fn fn_def_without_doc() {} // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.7: fn_def_def_with_doc' - // @has - 'fn_def_def_with_doc short' - // @!has - 'fn_def_def_with_doc full' + // @hasraw - 'fn_def_def_with_doc short' + // @!hasraw - 'fn_def_def_with_doc full' // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.0.8: fn_def_def_without_doc' } diff --git a/src/test/rustdoc/elided-lifetime.rs b/src/test/rustdoc/elided-lifetime.rs index 5a32554f972..9b4ceb4f9cd 100644 --- a/src/test/rustdoc/elided-lifetime.rs +++ b/src/test/rustdoc/elided-lifetime.rs @@ -11,33 +11,33 @@ pub struct Ref<'a>(&'a u32); type ARef<'a> = Ref<'a>; // @has foo/fn.test1.html -// @matches - "Ref</a><'_>" +// @matchesraw - "Ref</a><'_>" pub fn test1(a: &u32) -> Ref { Ref(a) } // @has foo/fn.test2.html -// @matches - "Ref</a><'_>" +// @matchesraw - "Ref</a><'_>" pub fn test2(a: &u32) -> Ref<'_> { Ref(a) } // @has foo/fn.test3.html -// @matches - "Ref</a><'_>" +// @matchesraw - "Ref</a><'_>" pub fn test3(a: &u32) -> ARef { Ref(a) } // @has foo/fn.test4.html -// @matches - "Ref</a><'_>" +// @matchesraw - "Ref</a><'_>" pub fn test4(a: &u32) -> ARef<'_> { Ref(a) } // Ensure external paths in inlined docs also display elided lifetime // @has foo/bar/fn.test5.html -// @matches - "Ref</a><'_>" +// @matchesraw - "Ref</a><'_>" // @has foo/bar/fn.test6.html -// @matches - "Ref</a><'_>" +// @matchesraw - "Ref</a><'_>" #[doc(inline)] pub extern crate bar; diff --git a/src/test/rustdoc/empty-mod-private.rs b/src/test/rustdoc/empty-mod-private.rs index c2a98049a48..147e11e5882 100644 --- a/src/test/rustdoc/empty-mod-private.rs +++ b/src/test/rustdoc/empty-mod-private.rs @@ -1,16 +1,16 @@ // compile-flags: --document-private-items // @has 'empty_mod_private/index.html' '//a[@href="foo/index.html"]' 'foo' -// @has 'empty_mod_private/sidebar-items.js' 'foo' +// @hasraw 'empty_mod_private/sidebar-items.js' 'foo' // @matches 'empty_mod_private/foo/index.html' '//h1' 'Module empty_mod_private::foo' mod foo {} // @has 'empty_mod_private/index.html' '//a[@href="bar/index.html"]' 'bar' -// @has 'empty_mod_private/sidebar-items.js' 'bar' +// @hasraw 'empty_mod_private/sidebar-items.js' 'bar' // @matches 'empty_mod_private/bar/index.html' '//h1' 'Module empty_mod_private::bar' mod bar { // @has 'empty_mod_private/bar/index.html' '//a[@href="baz/index.html"]' 'baz' - // @has 'empty_mod_private/bar/sidebar-items.js' 'baz' + // @hasraw 'empty_mod_private/bar/sidebar-items.js' 'baz' // @matches 'empty_mod_private/bar/baz/index.html' '//h1' 'Module empty_mod_private::bar::baz' mod baz {} } diff --git a/src/test/rustdoc/empty-mod-public.rs b/src/test/rustdoc/empty-mod-public.rs index d097fcf839c..c0bac40212c 100644 --- a/src/test/rustdoc/empty-mod-public.rs +++ b/src/test/rustdoc/empty-mod-public.rs @@ -1,14 +1,14 @@ // @has 'empty_mod_public/index.html' '//a[@href="foo/index.html"]' 'foo' -// @has 'empty_mod_public/sidebar-items.js' 'foo' +// @hasraw 'empty_mod_public/sidebar-items.js' 'foo' // @matches 'empty_mod_public/foo/index.html' '//h1' 'Module empty_mod_public::foo' pub mod foo {} // @has 'empty_mod_public/index.html' '//a[@href="bar/index.html"]' 'bar' -// @has 'empty_mod_public/sidebar-items.js' 'bar' +// @hasraw 'empty_mod_public/sidebar-items.js' 'bar' // @matches 'empty_mod_public/bar/index.html' '//h1' 'Module empty_mod_public::bar' pub mod bar { // @has 'empty_mod_public/bar/index.html' '//a[@href="baz/index.html"]' 'baz' - // @has 'empty_mod_public/bar/sidebar-items.js' 'baz' + // @hasraw 'empty_mod_public/bar/sidebar-items.js' 'baz' // @matches 'empty_mod_public/bar/baz/index.html' '//h1' 'Module empty_mod_public::bar::baz' pub mod baz {} } diff --git a/src/test/rustdoc/empty-section.rs b/src/test/rustdoc/empty-section.rs index 665aa38b11e..d8241ab96f6 100644 --- a/src/test/rustdoc/empty-section.rs +++ b/src/test/rustdoc/empty-section.rs @@ -5,7 +5,7 @@ pub struct Foo; // @has foo/struct.Foo.html -// @!has - 'Auto Trait Implementations' +// @!hasraw - 'Auto Trait Implementations' impl !Send for Foo {} impl !Sync for Foo {} impl !std::marker::Unpin for Foo {} diff --git a/src/test/rustdoc/generic-associated-types/issue-94683.rs b/src/test/rustdoc/generic-associated-types/issue-94683.rs index 38ecf528310..91499100ec6 100644 --- a/src/test/rustdoc/generic-associated-types/issue-94683.rs +++ b/src/test/rustdoc/generic-associated-types/issue-94683.rs @@ -8,6 +8,6 @@ pub trait Trait { // Make sure that the elided lifetime shows up // @has foo/type.T.html -// @has - "pub type T = " -// @has - "<'_>" +// @hasraw - "pub type T = " +// @hasraw - "<'_>" pub type T = fn(&<() as Trait>::Gat<'_>); diff --git a/src/test/rustdoc/hidden-impls.rs b/src/test/rustdoc/hidden-impls.rs index 8f33a6604c2..26e2e0e0660 100644 --- a/src/test/rustdoc/hidden-impls.rs +++ b/src/test/rustdoc/hidden-impls.rs @@ -11,7 +11,7 @@ pub mod __hidden { } // @has foo/trait.Clone.html -// @!has - 'Foo' +// @!hasraw - 'Foo' // @has implementors/core/clone/trait.Clone.js -// @!has - 'Foo' +// @!hasraw - 'Foo' pub use std::clone::Clone; diff --git a/src/test/rustdoc/hidden-line.rs b/src/test/rustdoc/hidden-line.rs index f2f6173d26d..00a05a7c26f 100644 --- a/src/test/rustdoc/hidden-line.rs +++ b/src/test/rustdoc/hidden-line.rs @@ -15,5 +15,5 @@ /// ``` pub fn foo() {} -// @!has hidden_line/fn.foo.html invisible +// @!hasraw hidden_line/fn.foo.html invisible // @matches - //pre "#\[derive\(PartialEq\)\] // Bar" diff --git a/src/test/rustdoc/hidden-methods.rs b/src/test/rustdoc/hidden-methods.rs index 27181d489f5..543d8f768a6 100644 --- a/src/test/rustdoc/hidden-methods.rs +++ b/src/test/rustdoc/hidden-methods.rs @@ -17,13 +17,13 @@ pub mod hidden { } // @has foo/struct.Foo.html -// @!has - 'Methods' +// @!hasraw - 'Methods' // @!has - '//code' 'impl Foo' -// @!has - 'this_should_be_hidden' +// @!hasraw - 'this_should_be_hidden' pub use hidden::Foo; // @has foo/struct.Bar.html -// @!has - 'Methods' +// @!hasraw - 'Methods' // @!has - '//code' 'impl Bar' -// @!has - 'this_should_be_hidden' +// @!hasraw - 'this_should_be_hidden' pub use hidden::Bar; diff --git a/src/test/rustdoc/hide-unstable-trait.rs b/src/test/rustdoc/hide-unstable-trait.rs index c30d6ed7b52..0bf7cabc43b 100644 --- a/src/test/rustdoc/hide-unstable-trait.rs +++ b/src/test/rustdoc/hide-unstable-trait.rs @@ -5,7 +5,7 @@ extern crate unstable_trait; -// @has foo/struct.Foo.html 'bar' -// @has foo/struct.Foo.html 'bar2' +// @hasraw foo/struct.Foo.html 'bar' +// @hasraw foo/struct.Foo.html 'bar2' #[doc(inline)] pub use unstable_trait::Foo; diff --git a/src/test/rustdoc/impl-parts-crosscrate.rs b/src/test/rustdoc/impl-parts-crosscrate.rs index 6c5e79d5aa3..34733f1f8cc 100644 --- a/src/test/rustdoc/impl-parts-crosscrate.rs +++ b/src/test/rustdoc/impl-parts-crosscrate.rs @@ -12,9 +12,9 @@ pub struct Bar<T> { t: T } // full impl string. Instead, just make sure something from each part // is mentioned. -// @has implementors/rustdoc_impl_parts_crosscrate/trait.AnAutoTrait.js Bar -// @has - Send -// @has - !AnAutoTrait -// @has - Copy +// @hasraw implementors/rustdoc_impl_parts_crosscrate/trait.AnAutoTrait.js Bar +// @hasraw - Send +// @hasraw - !AnAutoTrait +// @hasraw - Copy impl<T: Send> !rustdoc_impl_parts_crosscrate::AnAutoTrait for Bar<T> where T: Copy {} diff --git a/src/test/rustdoc/impl-trait-alias.rs b/src/test/rustdoc/impl-trait-alias.rs index 54c3f856ddb..4f681c78ee1 100644 --- a/src/test/rustdoc/impl-trait-alias.rs +++ b/src/test/rustdoc/impl-trait-alias.rs @@ -3,11 +3,11 @@ trait MyTrait {} impl MyTrait for i32 {} -// @has impl_trait_alias/type.Foo.html 'Foo' +// @hasraw impl_trait_alias/type.Foo.html 'Foo' /// debug type pub type Foo = impl MyTrait; -// @has impl_trait_alias/fn.foo.html 'foo' +// @hasraw impl_trait_alias/fn.foo.html 'foo' /// debug function pub fn foo() -> Foo { 1 diff --git a/src/test/rustdoc/inline_cross/add-docs.rs b/src/test/rustdoc/inline_cross/add-docs.rs index 8f0c4e5e641..a1124d2094c 100644 --- a/src/test/rustdoc/inline_cross/add-docs.rs +++ b/src/test/rustdoc/inline_cross/add-docs.rs @@ -4,6 +4,6 @@ extern crate inner; // @has add_docs/struct.MyStruct.html -// @has add_docs/struct.MyStruct.html "Doc comment from ‘pub use’, Doc comment from definition" +// @hasraw add_docs/struct.MyStruct.html "Doc comment from ‘pub use’, Doc comment from definition" /// Doc comment from 'pub use', pub use inner::MyStruct; diff --git a/src/test/rustdoc/inline_cross/assoc-items.rs b/src/test/rustdoc/inline_cross/assoc-items.rs index 231805a52b9..811827a17fe 100644 --- a/src/test/rustdoc/inline_cross/assoc-items.rs +++ b/src/test/rustdoc/inline_cross/assoc-items.rs @@ -7,10 +7,10 @@ extern crate assoc_items; // @has foo/struct.MyStruct.html -// @!has - 'PrivateConst' +// @!hasraw - 'PrivateConst' // @has - '//*[@id="associatedconstant.PublicConst"]' 'pub const PublicConst: u8' // @has - '//*[@class="docblock"]' 'docs for PublicConst' -// @!has - 'private_method' +// @!hasraw - 'private_method' // @has - '//*[@id="method.public_method"]' 'pub fn public_method()' // @has - '//*[@class="docblock"]' 'docs for public_method' // @has - '//*[@id="associatedconstant.ConstNoDefault"]' 'const ConstNoDefault: i16' diff --git a/src/test/rustdoc/inline_cross/hidden-use.rs b/src/test/rustdoc/inline_cross/hidden-use.rs index 97715737fd9..28a4f4bac1a 100644 --- a/src/test/rustdoc/inline_cross/hidden-use.rs +++ b/src/test/rustdoc/inline_cross/hidden-use.rs @@ -5,8 +5,8 @@ extern crate rustdoc_hidden; // @has hidden_use/index.html -// @!has - 'rustdoc_hidden' -// @!has - 'Bar' +// @!hasraw - 'rustdoc_hidden' +// @!hasraw - 'Bar' // @!has hidden_use/struct.Bar.html #[doc(hidden)] pub use rustdoc_hidden::Bar; diff --git a/src/test/rustdoc/inline_cross/proc_macro.rs b/src/test/rustdoc/inline_cross/proc_macro.rs index 532a295c0f3..a46550865c8 100644 --- a/src/test/rustdoc/inline_cross/proc_macro.rs +++ b/src/test/rustdoc/inline_cross/proc_macro.rs @@ -12,25 +12,25 @@ extern crate some_macros; // @has proc_macro/derive.SomeDerive.html // @has proc_macro/macro.some_proc_macro.html -// @has - 'a proc-macro that swallows its input and does nothing.' +// @hasraw - 'a proc-macro that swallows its input and does nothing.' pub use some_macros::some_proc_macro; // @has proc_macro/macro.reexported_macro.html -// @has - 'Doc comment from the original crate' +// @hasraw - 'Doc comment from the original crate' pub use some_macros::reexported_macro; // @has proc_macro/attr.some_proc_attr.html -// @has - 'a proc-macro attribute that passes its item through verbatim.' +// @hasraw - 'a proc-macro attribute that passes its item through verbatim.' pub use some_macros::some_proc_attr; // @has proc_macro/derive.SomeDerive.html -// @has - 'a derive attribute that adds nothing to its input.' +// @hasraw - 'a derive attribute that adds nothing to its input.' pub use some_macros::SomeDerive; // @has proc_macro/attr.first_attr.html -// @has - 'Generated doc comment' +// @hasraw - 'Generated doc comment' pub use some_macros::first_attr; // @has proc_macro/attr.second_attr.html -// @has - 'Generated doc comment' +// @hasraw - 'Generated doc comment' pub use some_macros::second_attr; diff --git a/src/test/rustdoc/inline_local/glob-extern-document-private-items.rs b/src/test/rustdoc/inline_local/glob-extern-document-private-items.rs index a2f0d65efce..8e1089d60ec 100644 --- a/src/test/rustdoc/inline_local/glob-extern-document-private-items.rs +++ b/src/test/rustdoc/inline_local/glob-extern-document-private-items.rs @@ -12,14 +12,14 @@ mod mod1 { pub use mod1::*; // @has foo/index.html -// @has - "mod1" -// @has - "public_fn" -// @!has - "private_fn" +// @hasraw - "mod1" +// @hasraw - "public_fn" +// @!hasraw - "private_fn" // @has foo/fn.public_fn.html // @!has foo/fn.private_fn.html // @has foo/mod1/index.html -// @has - "public_fn" -// @has - "private_fn" +// @hasraw - "public_fn" +// @hasraw - "private_fn" // @has foo/mod1/fn.public_fn.html // @has foo/mod1/fn.private_fn.html diff --git a/src/test/rustdoc/inline_local/glob-extern.rs b/src/test/rustdoc/inline_local/glob-extern.rs index 686e55de392..c592a4db19d 100644 --- a/src/test/rustdoc/inline_local/glob-extern.rs +++ b/src/test/rustdoc/inline_local/glob-extern.rs @@ -10,9 +10,9 @@ mod mod1 { pub use mod1::*; // @has foo/index.html -// @!has - "mod1" -// @has - "public_fn" -// @!has - "private_fn" +// @!hasraw - "mod1" +// @hasraw - "public_fn" +// @!hasraw - "private_fn" // @has foo/fn.public_fn.html // @!has foo/fn.private_fn.html diff --git a/src/test/rustdoc/inline_local/glob-private-document-private-items.rs b/src/test/rustdoc/inline_local/glob-private-document-private-items.rs index f16d21ecdb1..d8cbd42343b 100644 --- a/src/test/rustdoc/inline_local/glob-private-document-private-items.rs +++ b/src/test/rustdoc/inline_local/glob-private-document-private-items.rs @@ -15,31 +15,31 @@ mod mod1 { pub use mod1::*; // @has foo/index.html -// @has - "mod1" -// @has - "Mod1Public" -// @!has - "Mod1Private" -// @!has - "mod2" -// @has - "Mod2Public" -// @!has - "Mod2Private" +// @hasraw - "mod1" +// @hasraw - "Mod1Public" +// @!hasraw - "Mod1Private" +// @!hasraw - "mod2" +// @hasraw - "Mod2Public" +// @!hasraw - "Mod2Private" // @has foo/struct.Mod1Public.html // @!has foo/struct.Mod1Private.html // @has foo/struct.Mod2Public.html // @!has foo/struct.Mod2Private.html // @has foo/mod1/index.html -// @has - "mod2" -// @has - "Mod1Public" -// @has - "Mod1Private" -// @!has - "Mod2Public" -// @!has - "Mod2Private" +// @hasraw - "mod2" +// @hasraw - "Mod1Public" +// @hasraw - "Mod1Private" +// @!hasraw - "Mod2Public" +// @!hasraw - "Mod2Private" // @has foo/mod1/struct.Mod1Public.html // @has foo/mod1/struct.Mod1Private.html // @!has foo/mod1/struct.Mod2Public.html // @!has foo/mod1/struct.Mod2Private.html // @has foo/mod1/mod2/index.html -// @has - "Mod2Public" -// @has - "Mod2Private" +// @hasraw - "Mod2Public" +// @hasraw - "Mod2Private" // @has foo/mod1/mod2/struct.Mod2Public.html // @has foo/mod1/mod2/struct.Mod2Private.html diff --git a/src/test/rustdoc/inline_local/glob-private.rs b/src/test/rustdoc/inline_local/glob-private.rs index d294d590e1b..303f1d61048 100644 --- a/src/test/rustdoc/inline_local/glob-private.rs +++ b/src/test/rustdoc/inline_local/glob-private.rs @@ -13,12 +13,12 @@ mod mod1 { pub use mod1::*; // @has foo/index.html -// @!has - "mod1" -// @has - "Mod1Public" -// @!has - "Mod1Private" -// @!has - "mod2" -// @has - "Mod2Public" -// @!has - "Mod2Private" +// @!hasraw - "mod1" +// @hasraw - "Mod1Public" +// @!hasraw - "Mod1Private" +// @!hasraw - "mod2" +// @hasraw - "Mod2Public" +// @!hasraw - "Mod2Private" // @has foo/struct.Mod1Public.html // @!has foo/struct.Mod1Private.html // @has foo/struct.Mod2Public.html diff --git a/src/test/rustdoc/inline_local/hidden-use.rs b/src/test/rustdoc/inline_local/hidden-use.rs index a972d376aab..de512fb26e6 100644 --- a/src/test/rustdoc/inline_local/hidden-use.rs +++ b/src/test/rustdoc/inline_local/hidden-use.rs @@ -3,8 +3,8 @@ mod private { } // @has hidden_use/index.html -// @!has - 'private' -// @!has - 'Foo' +// @!hasraw - 'private' +// @!hasraw - 'Foo' // @!has hidden_use/struct.Foo.html #[doc(hidden)] pub use private::Foo; diff --git a/src/test/rustdoc/inline_local/macro_by_example.rs b/src/test/rustdoc/inline_local/macro_by_example.rs index dacc7cfb3cb..5c33c0037e4 100644 --- a/src/test/rustdoc/inline_local/macro_by_example.rs +++ b/src/test/rustdoc/inline_local/macro_by_example.rs @@ -7,7 +7,7 @@ macro_rules! foo { // @has macro_by_example/macros/index.html pub mod macros { - // @!has - 'pub use foo as bar;' + // @!hasraw - 'pub use foo as bar;' // @has macro_by_example/macros/macro.bar.html // @has - '//*[@class="docblock"]' 'docs for foo' // @has - '//*[@class="stab deprecated"]' 'Deprecated since 1.2.3: text' diff --git a/src/test/rustdoc/inline_local/please_inline.rs b/src/test/rustdoc/inline_local/please_inline.rs index 48539361fbf..e4429ef33a9 100644 --- a/src/test/rustdoc/inline_local/please_inline.rs +++ b/src/test/rustdoc/inline_local/please_inline.rs @@ -4,7 +4,7 @@ pub mod foo { // @has please_inline/a/index.html pub mod a { - // @!has - 'pub use foo::' + // @!hasraw - 'pub use foo::' // @has please_inline/a/struct.Foo.html #[doc(inline)] pub use foo::Foo; @@ -12,7 +12,7 @@ pub mod a { // @has please_inline/b/index.html pub mod b { - // @has - 'pub use foo::' + // @hasraw - 'pub use foo::' // @!has please_inline/b/struct.Foo.html #[feature(inline)] pub use foo::Foo; diff --git a/src/test/rustdoc/internal.rs b/src/test/rustdoc/internal.rs index f316eb24a48..caad43a087c 100644 --- a/src/test/rustdoc/internal.rs +++ b/src/test/rustdoc/internal.rs @@ -3,13 +3,15 @@ // Check that the unstable marker is not added for "rustc_private". // @!matches internal/index.html \ -// '//*[@class="item-right docblock-short"]/span[@class="stab unstable"]' +// '//*[@class="item-right docblock-short"]/span[@class="stab unstable"]' \ +// '' // @!matches internal/index.html \ -// '//*[@class="item-right docblock-short"]/span[@class="stab internal"]' +// '//*[@class="item-right docblock-short"]/span[@class="stab internal"]' \ +// '' // @matches - '//*[@class="item-right docblock-short"]' 'Docs' -// @!has internal/struct.S.html '//*[@class="stab unstable"]' -// @!has internal/struct.S.html '//*[@class="stab internal"]' +// @!has internal/struct.S.html '//*[@class="stab unstable"]' '' +// @!has internal/struct.S.html '//*[@class="stab internal"]' '' /// Docs pub struct S; diff --git a/src/test/rustdoc/intra-doc/extern-type.rs b/src/test/rustdoc/intra-doc/extern-type.rs index ab088ab789d..5440f582dff 100644 --- a/src/test/rustdoc/intra-doc/extern-type.rs +++ b/src/test/rustdoc/intra-doc/extern-type.rs @@ -25,11 +25,11 @@ impl G<usize> for ExternType { } // @has 'extern_type/foreigntype.ExternType.html' -// @has 'extern_type/fn.links_to_extern_type.html' \ +// @hasraw 'extern_type/fn.links_to_extern_type.html' \ // 'href="foreigntype.ExternType.html#method.f"' -// @has 'extern_type/fn.links_to_extern_type.html' \ +// @hasraw 'extern_type/fn.links_to_extern_type.html' \ // 'href="foreigntype.ExternType.html#method.test"' -// @has 'extern_type/fn.links_to_extern_type.html' \ +// @hasraw 'extern_type/fn.links_to_extern_type.html' \ // 'href="foreigntype.ExternType.html#method.g"' /// See also [ExternType::f] /// See also [ExternType::test] diff --git a/src/test/rustdoc/issue-16265-1.rs b/src/test/rustdoc/issue-16265-1.rs index ec007e36b72..2fda637a641 100644 --- a/src/test/rustdoc/issue-16265-1.rs +++ b/src/test/rustdoc/issue-16265-1.rs @@ -1,6 +1,6 @@ pub struct Foo; -// @has issue_16265_1/traits/index.html 'source' +// @hasraw issue_16265_1/traits/index.html 'source' pub mod traits { impl PartialEq for super::Foo { fn eq(&self, _: &super::Foo) -> bool { diff --git a/src/test/rustdoc/issue-16265-2.rs b/src/test/rustdoc/issue-16265-2.rs index d5cd18d9daf..c3eb356171e 100644 --- a/src/test/rustdoc/issue-16265-2.rs +++ b/src/test/rustdoc/issue-16265-2.rs @@ -1,4 +1,4 @@ -// @has issue_16265_2/index.html 'source' +// @hasraw issue_16265_2/index.html 'source' trait Y {} impl Y for Option<u32> {} diff --git a/src/test/rustdoc/issue-23511.rs b/src/test/rustdoc/issue-23511.rs index 2d2a7908fb1..7576ebb0305 100644 --- a/src/test/rustdoc/issue-23511.rs +++ b/src/test/rustdoc/issue-23511.rs @@ -6,7 +6,7 @@ pub mod str { #![doc(primitive = "str")] impl str { - // @has search-index.js foo + // @hasraw search-index.js foo #[rustc_allow_incoherent_impl] pub fn foo(&self) {} } diff --git a/src/test/rustdoc/issue-23812.rs b/src/test/rustdoc/issue-23812.rs index 5dac8d87b08..08fd1833bce 100644 --- a/src/test/rustdoc/issue-23812.rs +++ b/src/test/rustdoc/issue-23812.rs @@ -16,10 +16,10 @@ doc! { } // @has issue_23812/Foo/index.html -// @has - 'Outer comment' -// @!has - '/// Outer comment' -// @has - 'Inner comment' -// @!has - '//! Inner comment' +// @hasraw - 'Outer comment' +// @!hasraw - '/// Outer comment' +// @hasraw - 'Inner comment' +// @!hasraw - '//! Inner comment' doc! { @@ -30,7 +30,7 @@ doc! { } // @has issue_23812/Bar/index.html -// @has - 'Outer block comment' -// @!has - '/** Outer block comment */' -// @has - 'Inner block comment' -// @!has - '/*! Inner block comment */' +// @hasraw - 'Outer block comment' +// @!hasraw - '/** Outer block comment */' +// @hasraw - 'Inner block comment' +// @!hasraw - '/*! Inner block comment */' diff --git a/src/test/rustdoc/issue-27104.rs b/src/test/rustdoc/issue-27104.rs index b74c3eb78ac..9f2fd907114 100644 --- a/src/test/rustdoc/issue-27104.rs +++ b/src/test/rustdoc/issue-27104.rs @@ -3,8 +3,8 @@ // ignore-cross-compile // @has issue_27104/index.html -// @!has - 'extern crate std' -// @!has - 'use std::prelude::' +// @!hasraw - 'extern crate std' +// @!hasraw - 'use std::prelude::' -// @has - 'pub extern crate empty' +// @hasraw - 'pub extern crate empty' pub extern crate empty; diff --git a/src/test/rustdoc/issue-27759.rs b/src/test/rustdoc/issue-27759.rs index f3739dafdf2..65e0f7cb87b 100644 --- a/src/test/rustdoc/issue-27759.rs +++ b/src/test/rustdoc/issue-27759.rs @@ -4,11 +4,11 @@ #![unstable(feature="test", issue="27759")] // @has issue_27759/unstable/index.html -// @has - '<code>test</code> <a href="http://issue_url/27759">#27759</a>' +// @hasraw - '<code>test</code> <a href="http://issue_url/27759">#27759</a>' #[unstable(feature="test", issue="27759")] pub mod unstable { // @has issue_27759/unstable/fn.issue.html - // @has - '<code>test_function</code> <a href="http://issue_url/12345">#12345</a>' + // @hasraw - '<code>test_function</code> <a href="http://issue_url/12345">#12345</a>' #[unstable(feature="test_function", issue="12345")] pub fn issue() {} } diff --git a/src/test/rustdoc/issue-29584.rs b/src/test/rustdoc/issue-29584.rs index 28e1efec608..4364a9649b5 100644 --- a/src/test/rustdoc/issue-29584.rs +++ b/src/test/rustdoc/issue-29584.rs @@ -4,5 +4,5 @@ extern crate issue_29584; // @has issue_29584/struct.Foo.html -// @!has - 'impl Bar for' +// @!hasraw - 'impl Bar for' pub use issue_29584::Foo; diff --git a/src/test/rustdoc/issue-31899.rs b/src/test/rustdoc/issue-31899.rs index e7a8ee239e2..3eee374465d 100644 --- a/src/test/rustdoc/issue-31899.rs +++ b/src/test/rustdoc/issue-31899.rs @@ -1,8 +1,8 @@ // @has issue_31899/index.html -// @has - 'Make this line a bit longer.' -// @!has - 'rust rust-example-rendered' -// @!has - 'use ndarray::arr2' -// @!has - 'prohibited' +// @hasraw - 'Make this line a bit longer.' +// @!hasraw - 'rust rust-example-rendered' +// @!hasraw - 'use ndarray::arr2' +// @!hasraw - 'prohibited' /// A tuple or fixed size array that can be used to index an array. /// Make this line a bit longer. diff --git a/src/test/rustdoc/issue-32374.rs b/src/test/rustdoc/issue-32374.rs index 01f95538196..9c585497d35 100644 --- a/src/test/rustdoc/issue-32374.rs +++ b/src/test/rustdoc/issue-32374.rs @@ -10,7 +10,7 @@ // @has issue_32374/struct.T.html '//*[@class="stab deprecated"]' \ // '👎 Deprecated since 1.0.0: text' -// @has - '<code>test</code> <a href="https://issue_url/32374">#32374</a>' +// @hasraw - '<code>test</code> <a href="https://issue_url/32374">#32374</a>' // @matches issue_32374/struct.T.html '//*[@class="stab unstable"]' \ // '🔬 This is a nightly-only experimental API. \(test\s#32374\)$' /// Docs diff --git a/src/test/rustdoc/issue-32395.rs b/src/test/rustdoc/issue-32395.rs index 13468c15313..5552300f9fe 100644 --- a/src/test/rustdoc/issue-32395.rs +++ b/src/test/rustdoc/issue-32395.rs @@ -3,13 +3,13 @@ // ignore-cross-compile // @has variant_struct/enum.Foo.html -// @!has - 'pub qux' -// @!has - 'pub(crate) qux' -// @!has - 'pub Bar' +// @!hasraw - 'pub qux' +// @!hasraw - 'pub(crate) qux' +// @!hasraw - 'pub Bar' extern crate variant_struct; // @has issue_32395/enum.Foo.html -// @!has - 'pub qux' -// @!has - 'pub(crate) qux' -// @!has - 'pub Bar' +// @!hasraw - 'pub qux' +// @!hasraw - 'pub(crate) qux' +// @!hasraw - 'pub Bar' pub use variant_struct::Foo; diff --git a/src/test/rustdoc/issue-34473.rs b/src/test/rustdoc/issue-34473.rs index d96301f3ae7..37da3dd1999 100644 --- a/src/test/rustdoc/issue-34473.rs +++ b/src/test/rustdoc/issue-34473.rs @@ -5,7 +5,7 @@ mod second { } // @has foo/index.html -// @!has - SomeTypeWithLongName +// @!hasraw - SomeTypeWithLongName // @has foo/struct.SomeType.html // @!has foo/struct.SomeTypeWithLongName.html pub use second::{SomeTypeWithLongName as SomeType}; diff --git a/src/test/rustdoc/issue-41783.rs b/src/test/rustdoc/issue-41783.rs index cb9b9b15389..58a55a73815 100644 --- a/src/test/rustdoc/issue-41783.rs +++ b/src/test/rustdoc/issue-41783.rs @@ -1,11 +1,11 @@ // @has issue_41783/struct.Foo.html -// @!has - 'space' -// @!has - 'comment' -// @has - '# <span class="ident">single' -// @has - '## <span class="ident">double</span>' -// @has - '### <span class="ident">triple</span>' -// @has - '<span class="attribute">#[<span class="ident">outer</span>]</span>' -// @has - '<span class="attribute">#![<span class="ident">inner</span>]</span>' +// @!hasraw - 'space' +// @!hasraw - 'comment' +// @hasraw - '# <span class="ident">single' +// @hasraw - '## <span class="ident">double</span>' +// @hasraw - '### <span class="ident">triple</span>' +// @hasraw - '<span class="attribute">#[<span class="ident">outer</span>]</span>' +// @hasraw - '<span class="attribute">#![<span class="ident">inner</span>]</span>' /// ```no_run /// # # space diff --git a/src/test/rustdoc/issue-53689.rs b/src/test/rustdoc/issue-53689.rs index 52ce4159d82..832140e061b 100644 --- a/src/test/rustdoc/issue-53689.rs +++ b/src/test/rustdoc/issue-53689.rs @@ -5,7 +5,7 @@ extern crate issue_53689; // @has foo/trait.MyTrait.html -// @!has - 'MyStruct' +// @!hasraw - 'MyStruct' // @count - '//*[h3="impl<T> MyTrait for T"]' 1 pub trait MyTrait {} diff --git a/src/test/rustdoc/issue-61592.rs b/src/test/rustdoc/issue-61592.rs index aef038c07d8..4b6c37b94aa 100644 --- a/src/test/rustdoc/issue-61592.rs +++ b/src/test/rustdoc/issue-61592.rs @@ -5,11 +5,11 @@ extern crate foo; // @has issue_61592/index.html // @has - '//a[@href="#reexports"]' 'Re-exports' // @has - '//code' 'pub use foo::FooTrait as _;' -// @!has - '//a[@href="trait._.html"]' +// @!has - '//a[@href="trait._.html"]' '' pub use foo::FooTrait as _; // @has issue_61592/index.html // @has - '//a[@href="#reexports"]' 'Re-exports' // @has - '//code' 'pub use foo::FooStruct as _;' -// @!has - '//a[@href="struct._.html"]' +// @!has - '//a[@href="struct._.html"]' '' pub use foo::FooStruct as _; diff --git a/src/test/rustdoc/issue-89852.rs b/src/test/rustdoc/issue-89852.rs index 45544dbeea6..4f2da5e07be 100644 --- a/src/test/rustdoc/issue-89852.rs +++ b/src/test/rustdoc/issue-89852.rs @@ -3,8 +3,8 @@ #![no_core] #![feature(no_core)] -// @matches 'issue_89852/sidebar-items.js' '"repro"' -// @!matches 'issue_89852/sidebar-items.js' '"repro".*"repro"' +// @matchesraw 'issue_89852/sidebar-items.js' '"repro"' +// @!matchesraw 'issue_89852/sidebar-items.js' '"repro".*"repro"' #[macro_export] macro_rules! repro { diff --git a/src/test/rustdoc/link-title-escape.rs b/src/test/rustdoc/link-title-escape.rs index 01aa8d00b70..7a322ea6d34 100644 --- a/src/test/rustdoc/link-title-escape.rs +++ b/src/test/rustdoc/link-title-escape.rs @@ -6,4 +6,4 @@ //! //! [foo]: url 'title & <stuff> & "things"' -// @has 'foo/index.html' 'title & <stuff> & "things"' +// @hasraw 'foo/index.html' 'title & <stuff> & "things"' diff --git a/src/test/rustdoc/macro-document-private-duplicate.rs b/src/test/rustdoc/macro-document-private-duplicate.rs index 7576c1326b8..ee301051441 100644 --- a/src/test/rustdoc/macro-document-private-duplicate.rs +++ b/src/test/rustdoc/macro-document-private-duplicate.rs @@ -10,15 +10,15 @@ // // compile-flags: --document-private-items -// @has macro_document_private_duplicate/index.html 'Doc 1.' -// @has macro_document_private_duplicate/macro.a_macro.html 'Doc 1.' +// @hasraw macro_document_private_duplicate/index.html 'Doc 1.' +// @hasraw macro_document_private_duplicate/macro.a_macro.html 'Doc 1.' /// Doc 1. macro_rules! a_macro { () => () } -// @has macro_document_private_duplicate/index.html 'Doc 2.' -// @!has macro_document_private_duplicate/macro.a_macro.html 'Doc 2.' +// @hasraw macro_document_private_duplicate/index.html 'Doc 2.' +// @!hasraw macro_document_private_duplicate/macro.a_macro.html 'Doc 2.' /// Doc 2. macro_rules! a_macro { () => () diff --git a/src/test/rustdoc/macro-private-not-documented.rs b/src/test/rustdoc/macro-private-not-documented.rs index ae8b0e7229f..f135a3a9ca6 100644 --- a/src/test/rustdoc/macro-private-not-documented.rs +++ b/src/test/rustdoc/macro-private-not-documented.rs @@ -6,13 +6,13 @@ // This is a regression text for issue #88453. #![feature(decl_macro)] -// @!has macro_private_not_documented/index.html 'a_macro' +// @!hasraw macro_private_not_documented/index.html 'a_macro' // @!has macro_private_not_documented/macro.a_macro.html macro_rules! a_macro { () => () } -// @!has macro_private_not_documented/index.html 'another_macro' +// @!hasraw macro_private_not_documented/index.html 'another_macro' // @!has macro_private_not_documented/macro.another_macro.html macro another_macro { () => () diff --git a/src/test/rustdoc/macro_rules-matchers.rs b/src/test/rustdoc/macro_rules-matchers.rs index efc3b21e6da..98026663e5a 100644 --- a/src/test/rustdoc/macro_rules-matchers.rs +++ b/src/test/rustdoc/macro_rules-matchers.rs @@ -6,31 +6,28 @@ // @has 'foo/macro.todo.html' // @has - '//span[@class="macro"]' 'macro_rules!' // @has - '//span[@class="ident"]' 'todo' -// Note: the only op is the `+` -// @count - '//pre[@class="rust macro"]//span[@class="op"]' 1 -// @has - '{ () => { ... }; ($(' +// @hasraw - '{ () => { ... }; ($(' // @has - '//span[@class="macro-nonterminal"]' '$' // @has - '//span[@class="macro-nonterminal"]' 'arg' -// @has - ':' +// @hasraw - ':' // @has - '//span[@class="ident"]' 'tt' -// @has - '),' -// @has - '//span[@class="op"]' '+' -// @has - ') => { ... }; }' +// @hasraw - ')+' +// @hasraw - ') => { ... }; }' pub use std::todo; mod mod1 { // @has 'foo/macro.macro1.html' - // @has - 'macro_rules!' - // @has - 'macro1' - // @has - '{ () => { ... }; ($(' + // @hasraw - 'macro_rules!' + // @hasraw - 'macro1' + // @hasraw - '{ () => { ... }; ($(' // @has - '//span[@class="macro-nonterminal"]' '$' // @has - '//span[@class="macro-nonterminal"]' 'arg' - // @has - ':' - // @has - 'expr' - // @has - '),' - // @has - '+' - // @has - ') => { ... }; }' + // @hasraw - ':' + // @hasraw - 'expr' + // @hasraw - '),' + // @hasraw - '+' + // @hasraw - ') => { ... }; }' #[macro_export] macro_rules! macro1 { () => {}; diff --git a/src/test/rustdoc/markdown-summaries.rs b/src/test/rustdoc/markdown-summaries.rs index b843e28e7b0..31e7072b5ce 100644 --- a/src/test/rustdoc/markdown-summaries.rs +++ b/src/test/rustdoc/markdown-summaries.rs @@ -7,21 +7,21 @@ //! //! [link]: https://example.com -// @has search-index.js 'This <em>summary</em> has a link and <code>code</code>.' -// @!has - 'second paragraph' +// @hasraw search-index.js 'This <em>summary</em> has a link and <code>code</code>.' +// @!hasraw - 'second paragraph' /// This `code` will be rendered in a code tag. /// /// This text should not be rendered. pub struct Sidebar; -// @has search-index.js 'This <code>code</code> will be rendered in a code tag.' -// @has summaries/sidebar-items.js 'This `code` will be rendered in a code tag.' -// @!has - 'text should not be rendered' +// @hasraw search-index.js 'This <code>code</code> will be rendered in a code tag.' +// @hasraw summaries/sidebar-items.js 'This `code` will be rendered in a code tag.' +// @!hasraw - 'text should not be rendered' /// ```text /// this block should not be rendered /// ``` pub struct Sidebar2; -// @!has summaries/sidebar-items.js 'block should not be rendered' +// @!hasraw summaries/sidebar-items.js 'block should not be rendered' diff --git a/src/test/rustdoc/masked.rs b/src/test/rustdoc/masked.rs index c7ad690d66e..80d5b99c0b0 100644 --- a/src/test/rustdoc/masked.rs +++ b/src/test/rustdoc/masked.rs @@ -7,24 +7,24 @@ #[doc(masked)] extern crate masked; -// @!has 'search-index.js' 'masked_method' +// @!hasraw 'search-index.js' 'masked_method' -// @!has 'foo/struct.String.html' 'MaskedTrait' -// @!has 'foo/struct.String.html' 'masked_method' +// @!hasraw 'foo/struct.String.html' 'MaskedTrait' +// @!hasraw 'foo/struct.String.html' 'masked_method' pub use std::string::String; -// @!has 'foo/trait.Clone.html' 'MaskedStruct' +// @!hasraw 'foo/trait.Clone.html' 'MaskedStruct' pub use std::clone::Clone; -// @!has 'foo/struct.MyStruct.html' 'MaskedTrait' -// @!has 'foo/struct.MyStruct.html' 'masked_method' +// @!hasraw 'foo/struct.MyStruct.html' 'MaskedTrait' +// @!hasraw 'foo/struct.MyStruct.html' 'masked_method' pub struct MyStruct; impl masked::MaskedTrait for MyStruct { fn masked_method() {} } -// @!has 'foo/trait.MyTrait.html' 'MaskedStruct' +// @!hasraw 'foo/trait.MyTrait.html' 'MaskedStruct' pub trait MyTrait {} impl MyTrait for masked::MaskedStruct {} diff --git a/src/test/rustdoc/module-impls.rs b/src/test/rustdoc/module-impls.rs index 198b3446c61..852f444e99b 100644 --- a/src/test/rustdoc/module-impls.rs +++ b/src/test/rustdoc/module-impls.rs @@ -2,4 +2,4 @@ pub use std::marker::Send; -// @!has foo/index.html 'Implementations' +// @!hasraw foo/index.html 'Implementations' diff --git a/src/test/rustdoc/nested-modules.rs b/src/test/rustdoc/nested-modules.rs index 1596f46740e..12234d2cf7e 100644 --- a/src/test/rustdoc/nested-modules.rs +++ b/src/test/rustdoc/nested-modules.rs @@ -7,22 +7,22 @@ mod a_module { pub mod a_nested_module { // @has aCrate/a_nested_module/index.html '//a[@href="fn.a_nested_public_function.html"]' 'a_nested_public_function' - // @has aCrate/a_nested_module/fn.a_nested_public_function.html 'pub fn a_nested_public_function()' + // @hasraw aCrate/a_nested_module/fn.a_nested_public_function.html 'pub fn a_nested_public_function()' pub fn a_nested_public_function() {} // @has aCrate/a_nested_module/index.html '//a[@href="fn.another_nested_public_function.html"]' 'another_nested_public_function' - // @has aCrate/a_nested_module/fn.another_nested_public_function.html 'pub fn another_nested_public_function()' + // @hasraw aCrate/a_nested_module/fn.another_nested_public_function.html 'pub fn another_nested_public_function()' pub use a_nested_module::a_nested_public_function as another_nested_public_function; } - // @!has aCrate/a_nested_module/index.html 'yet_another_nested_public_function' + // @!hasraw aCrate/a_nested_module/index.html 'yet_another_nested_public_function' pub use a_nested_module::a_nested_public_function as yet_another_nested_public_function; - // @!has aCrate/a_nested_module/index.html 'one_last_nested_public_function' + // @!hasraw aCrate/a_nested_module/index.html 'one_last_nested_public_function' pub use a_nested_module::another_nested_public_function as one_last_nested_public_function; } -// @!has aCrate/index.html 'a_module' +// @!hasraw aCrate/index.html 'a_module' // @has aCrate/index.html '//a[@href="a_nested_module/index.html"]' 'a_nested_module' pub use a_module::a_nested_module; @@ -36,7 +36,7 @@ pub use a_module::{ }; // @has aCrate/index.html '//a[@href="fn.private_function.html"]' 'private_function' -// @!has aCrate/fn.private_function.html 'a_module' +// @!hasraw aCrate/fn.private_function.html 'a_module' // @has aCrate/index.html '//a[@href="fn.other_private_function.html"]' 'other_private_function' -// @!has aCrate/fn.other_private_function.html 'a_module' +// @!hasraw aCrate/fn.other_private_function.html 'a_module' pub use a_module::{other_private_function, private_function}; diff --git a/src/test/rustdoc/no-crate-filter.rs b/src/test/rustdoc/no-crate-filter.rs index c694d1456ef..b2f89906480 100644 --- a/src/test/rustdoc/no-crate-filter.rs +++ b/src/test/rustdoc/no-crate-filter.rs @@ -2,5 +2,5 @@ // compile-flags: -Z unstable-options --disable-per-crate-search -// @!has 'foo/struct.Foo.html' '//*[id="crate-search"]' +// @!has 'foo/struct.Foo.html' '//*[id="crate-search"]' '' pub struct Foo; diff --git a/src/test/rustdoc/recursive-deref.rs b/src/test/rustdoc/recursive-deref.rs index a7504fbccfb..2ab9d44be6d 100644 --- a/src/test/rustdoc/recursive-deref.rs +++ b/src/test/rustdoc/recursive-deref.rs @@ -51,7 +51,7 @@ impl G { // @has recursive_deref/struct.D.html '//h3[@class="code-header in-band"]' 'impl Deref for D' // We also check that `G::g` method isn't rendered because there is no `self` argument. -// @!has '-' '//*[@id="deref-methods-G"]' +// @!has '-' '//*[@id="deref-methods-G"]' '' impl Deref for D { type Target = E; @@ -62,7 +62,7 @@ impl Deref for D { // @has recursive_deref/struct.E.html '//h3[@class="code-header in-band"]' 'impl Deref for E' // We also check that `G::g` method isn't rendered because there is no `self` argument. -// @!has '-' '//*[@id="deref-methods-G"]' +// @!has '-' '//*[@id="deref-methods-G"]' '' impl Deref for E { type Target = F; @@ -73,7 +73,7 @@ impl Deref for E { // @has recursive_deref/struct.F.html '//h3[@class="code-header in-band"]' 'impl Deref for F' // We also check that `G::g` method isn't rendered because there is no `self` argument. -// @!has '-' '//*[@id="deref-methods-G"]' +// @!has '-' '//*[@id="deref-methods-G"]' '' impl Deref for F { type Target = G; @@ -101,7 +101,7 @@ impl I { } // @has recursive_deref/struct.H.html '//h3[@class="code-header in-band"]' 'impl Deref for H' -// @!has '-' '//*[@id="deref-methods-I"]' +// @!has '-' '//*[@id="deref-methods-I"]' '' impl Deref for H { type Target = I; diff --git a/src/test/rustdoc/remove-url-from-headings.rs b/src/test/rustdoc/remove-url-from-headings.rs index e2b232a6efb..599c429a6e1 100644 --- a/src/test/rustdoc/remove-url-from-headings.rs +++ b/src/test/rustdoc/remove-url-from-headings.rs @@ -1,7 +1,7 @@ #![crate_name = "foo"] // @has foo/fn.foo.html -// @!has - '//a[@href="http://a.a"]' +// @!has - '//a[@href="http://a.a"]' '' // @has - '//a[@href="#implementing-stuff-somewhere"]' 'Implementing stuff somewhere' // @has - '//a[@href="#another-one-urg"]' 'Another one urg' diff --git a/src/test/rustdoc/search-index-summaries.rs b/src/test/rustdoc/search-index-summaries.rs index dd9c1a0b47d..efd366405bf 100644 --- a/src/test/rustdoc/search-index-summaries.rs +++ b/src/test/rustdoc/search-index-summaries.rs @@ -1,8 +1,8 @@ #![crate_name = "foo"] -// @has 'search-index.js' 'Foo short link.' -// @!has - 'www.example.com' -// @!has - 'More Foo.' +// @hasraw 'search-index.js' 'Foo short link.' +// @!hasraw - 'www.example.com' +// @!hasraw - 'More Foo.' /// Foo short [link](https://www.example.com/). /// diff --git a/src/test/rustdoc/search-index.rs b/src/test/rustdoc/search-index.rs index f1b78f17277..d1d05eb886b 100644 --- a/src/test/rustdoc/search-index.rs +++ b/src/test/rustdoc/search-index.rs @@ -2,25 +2,25 @@ use std::ops::Deref; -// @has search-index.js Foo +// @hasraw search-index.js Foo pub use private::Foo; mod private { pub struct Foo; impl Foo { - pub fn test_method() {} // @has - test_method - fn priv_method() {} // @!has - priv_method + pub fn test_method() {} // @hasraw - test_method + fn priv_method() {} // @!hasraw - priv_method } pub trait PrivateTrait { - fn trait_method(&self) {} // @!has - priv_method + fn trait_method(&self) {} // @!hasraw - priv_method } } pub struct Bar; impl Deref for Bar { - // @!has search-index.js Target + // @!hasraw search-index.js Target type Target = Bar; fn deref(&self) -> &Bar { self } } diff --git a/src/test/rustdoc/show-const-contents.rs b/src/test/rustdoc/show-const-contents.rs index 48b60885974..69e742ee747 100644 --- a/src/test/rustdoc/show-const-contents.rs +++ b/src/test/rustdoc/show-const-contents.rs @@ -1,57 +1,57 @@ // Test that the contents of constants are displayed as part of the // documentation. -// @has show_const_contents/constant.CONST_S.html 'show this' -// @!has show_const_contents/constant.CONST_S.html '; //' +// @hasraw show_const_contents/constant.CONST_S.html 'show this' +// @!hasraw show_const_contents/constant.CONST_S.html '; //' pub const CONST_S: &'static str = "show this"; -// @has show_const_contents/constant.CONST_I32.html '= 42;' -// @!has show_const_contents/constant.CONST_I32.html '; //' +// @hasraw show_const_contents/constant.CONST_I32.html '= 42;' +// @!hasraw show_const_contents/constant.CONST_I32.html '; //' pub const CONST_I32: i32 = 42; -// @has show_const_contents/constant.CONST_I32_HEX.html '= 0x42;' -// @!has show_const_contents/constant.CONST_I32_HEX.html '; //' +// @hasraw show_const_contents/constant.CONST_I32_HEX.html '= 0x42;' +// @!hasraw show_const_contents/constant.CONST_I32_HEX.html '; //' pub const CONST_I32_HEX: i32 = 0x42; -// @has show_const_contents/constant.CONST_NEG_I32.html '= -42;' -// @!has show_const_contents/constant.CONST_NEG_I32.html '; //' +// @hasraw show_const_contents/constant.CONST_NEG_I32.html '= -42;' +// @!hasraw show_const_contents/constant.CONST_NEG_I32.html '; //' pub const CONST_NEG_I32: i32 = -42; -// @has show_const_contents/constant.CONST_EQ_TO_VALUE_I32.html '= 42i32;' -// @!has show_const_contents/constant.CONST_EQ_TO_VALUE_I32.html '// 42i32' +// @hasraw show_const_contents/constant.CONST_EQ_TO_VALUE_I32.html '= 42i32;' +// @!hasraw show_const_contents/constant.CONST_EQ_TO_VALUE_I32.html '// 42i32' pub const CONST_EQ_TO_VALUE_I32: i32 = 42i32; -// @has show_const_contents/constant.CONST_CALC_I32.html '= _; // 43i32' +// @hasraw show_const_contents/constant.CONST_CALC_I32.html '= _; // 43i32' pub const CONST_CALC_I32: i32 = 42 + 1; -// @!has show_const_contents/constant.CONST_REF_I32.html '= &42;' -// @!has show_const_contents/constant.CONST_REF_I32.html '; //' +// @!hasraw show_const_contents/constant.CONST_REF_I32.html '= &42;' +// @!hasraw show_const_contents/constant.CONST_REF_I32.html '; //' pub const CONST_REF_I32: &'static i32 = &42; -// @has show_const_contents/constant.CONST_I32_MAX.html '= i32::MAX; // 2_147_483_647i32' +// @hasraw show_const_contents/constant.CONST_I32_MAX.html '= i32::MAX; // 2_147_483_647i32' pub const CONST_I32_MAX: i32 = i32::MAX; -// @!has show_const_contents/constant.UNIT.html '= ();' -// @!has show_const_contents/constant.UNIT.html '; //' +// @!hasraw show_const_contents/constant.UNIT.html '= ();' +// @!hasraw show_const_contents/constant.UNIT.html '; //' pub const UNIT: () = (); pub struct MyType(i32); -// @!has show_const_contents/constant.MY_TYPE.html '= MyType(42);' -// @!has show_const_contents/constant.MY_TYPE.html '; //' +// @!hasraw show_const_contents/constant.MY_TYPE.html '= MyType(42);' +// @!hasraw show_const_contents/constant.MY_TYPE.html '; //' pub const MY_TYPE: MyType = MyType(42); pub struct MyTypeWithStr(&'static str); -// @!has show_const_contents/constant.MY_TYPE_WITH_STR.html '= MyTypeWithStr("show this");' -// @!has show_const_contents/constant.MY_TYPE_WITH_STR.html '; //' +// @!hasraw show_const_contents/constant.MY_TYPE_WITH_STR.html '= MyTypeWithStr("show this");' +// @!hasraw show_const_contents/constant.MY_TYPE_WITH_STR.html '; //' pub const MY_TYPE_WITH_STR: MyTypeWithStr = MyTypeWithStr("show this"); -// @has show_const_contents/constant.PI.html '= 3.14159265358979323846264338327950288f32;' -// @has show_const_contents/constant.PI.html '; // 3.14159274f32' +// @hasraw show_const_contents/constant.PI.html '= 3.14159265358979323846264338327950288f32;' +// @hasraw show_const_contents/constant.PI.html '; // 3.14159274f32' pub use std::f32::consts::PI; -// @has show_const_contents/constant.MAX.html '= i32::MAX; // 2_147_483_647i32' +// @hasraw show_const_contents/constant.MAX.html '= i32::MAX; // 2_147_483_647i32' #[allow(deprecated, deprecated_in_future)] pub use std::i32::MAX; @@ -61,7 +61,7 @@ macro_rules! int_module { ) } -// @has show_const_contents/constant.MIN.html '= i16::MIN; // -32_768i16' +// @hasraw show_const_contents/constant.MIN.html '= i16::MIN; // -32_768i16' int_module!(i16); // @has show_const_contents/constant.ESCAPE.html //pre '= r#"<script>alert("ESCAPE");</script>"#;' diff --git a/src/test/rustdoc/sized_trait.rs b/src/test/rustdoc/sized_trait.rs index 9d2c1967757..36718ebe1a6 100644 --- a/src/test/rustdoc/sized_trait.rs +++ b/src/test/rustdoc/sized_trait.rs @@ -1,13 +1,13 @@ #![crate_name = "foo"] // @has foo/struct.Bar.html -// @!has - '//*[@id="impl-Sized"]' +// @!has - '//*[@id="impl-Sized"]' '' pub struct Bar { a: u16, } // @has foo/struct.Foo.html -// @!has - '//*[@id="impl-Sized"]' +// @!has - '//*[@id="impl-Sized"]' '' pub struct Foo<T: ?Sized>(T); // @has foo/struct.Unsized.html diff --git a/src/test/rustdoc/sort-modules-by-appearance.rs b/src/test/rustdoc/sort-modules-by-appearance.rs index 5be6b98264a..b5cc8bc8304 100644 --- a/src/test/rustdoc/sort-modules-by-appearance.rs +++ b/src/test/rustdoc/sort-modules-by-appearance.rs @@ -9,5 +9,5 @@ pub mod module_c {} pub mod module_a {} -// @matches 'sort_modules_by_appearance/index.html' '(?s)module_b.*module_c.*module_a' -// @matches 'sort_modules_by_appearance/sidebar-items.js' '"module_b".*"module_c".*"module_a"' +// @matchesraw 'sort_modules_by_appearance/index.html' '(?s)module_b.*module_c.*module_a' +// @matchesraw 'sort_modules_by_appearance/sidebar-items.js' '"module_b".*"module_c".*"module_a"' diff --git a/src/test/rustdoc/source-file.rs b/src/test/rustdoc/source-file.rs index 968899dab88..4e166479063 100644 --- a/src/test/rustdoc/source-file.rs +++ b/src/test/rustdoc/source-file.rs @@ -1,5 +1,5 @@ #![crate_name = "foo"] -// @has source-files.js source-file.rs +// @hasraw source-files.js source-file.rs pub struct Foo; diff --git a/src/test/rustdoc/static-root-path.rs b/src/test/rustdoc/static-root-path.rs index f1d49b9fcb2..08c055c5b8d 100644 --- a/src/test/rustdoc/static-root-path.rs +++ b/src/test/rustdoc/static-root-path.rs @@ -1,18 +1,18 @@ // compile-flags:-Z unstable-options --static-root-path /cache/ // @has static_root_path/struct.SomeStruct.html -// @matches - '"/cache/main\.js"' -// @!matches - '"\.\./main\.js"' -// @matches - 'data-root-path="\.\./"' -// @!matches - '"/cache/search-index\.js"' +// @matchesraw - '"/cache/main\.js"' +// @!matchesraw - '"\.\./main\.js"' +// @matchesraw - 'data-root-path="\.\./"' +// @!matchesraw - '"/cache/search-index\.js"' pub struct SomeStruct; // @has src/static_root_path/static-root-path.rs.html -// @matches - '"/cache/source-script\.js"' -// @!matches - '"\.\./\.\./source-script\.js"' -// @matches - '"\.\./\.\./source-files.js"' -// @!matches - '"/cache/source-files\.js"' +// @matchesraw - '"/cache/source-script\.js"' +// @!matchesraw - '"\.\./\.\./source-script\.js"' +// @matchesraw - '"\.\./\.\./source-files.js"' +// @!matchesraw - '"/cache/source-files\.js"' // @has settings.html -// @matches - '/cache/settings\.js' -// @!matches - '\./settings\.js' +// @matchesraw - '/cache/settings\.js' +// @!matchesraw - '\./settings\.js' diff --git a/src/test/rustdoc/table-in-docblock.rs b/src/test/rustdoc/table-in-docblock.rs index 858b589196e..194f49f16d0 100644 --- a/src/test/rustdoc/table-in-docblock.rs +++ b/src/test/rustdoc/table-in-docblock.rs @@ -2,7 +2,7 @@ // @has foo/struct.Foo.html // @count - '//*[@class="docblock"]/div/table' 2 -// @!has - '//*[@class="docblock"]/table' +// @!has - '//*[@class="docblock"]/table' '' /// | hello | hello2 | /// | ----- | ------ | /// | data | data2 | diff --git a/src/test/rustdoc/toggle-item-contents.rs b/src/test/rustdoc/toggle-item-contents.rs index c1df4613e35..dbaf195e1a9 100644 --- a/src/test/rustdoc/toggle-item-contents.rs +++ b/src/test/rustdoc/toggle-item-contents.rs @@ -62,7 +62,7 @@ pub struct PrivStruct { } // @has 'toggle_item_contents/enum.Enum.html' -// @!has - '//details[@class="rustdoc-toggle type-contents-toggle"]' +// @!has - '//details[@class="rustdoc-toggle type-contents-toggle"]' '' pub enum Enum { A, B, C, D { @@ -72,7 +72,7 @@ pub enum Enum { } // @has 'toggle_item_contents/enum.EnumStructVariant.html' -// @!has - '//details[@class="rustdoc-toggle type-contents-toggle"]' +// @!has - '//details[@class="rustdoc-toggle type-contents-toggle"]' '' pub enum EnumStructVariant { A, B, C, D { diff --git a/src/test/rustdoc/trait-impl-items-links-and-anchors.rs b/src/test/rustdoc/trait-impl-items-links-and-anchors.rs index b5a97c610da..fba594c3827 100644 --- a/src/test/rustdoc/trait-impl-items-links-and-anchors.rs +++ b/src/test/rustdoc/trait-impl-items-links-and-anchors.rs @@ -59,7 +59,7 @@ pub struct MyStruct; // We check that associated items with default values aren't generated in the implementors list. impl MyTrait for (u8, u8) { - // @!has trait_impl_items_links_and_anchors/trait.MyTrait.html '//div[@id="associatedconstant.VALUE-4"]' + // @!has trait_impl_items_links_and_anchors/trait.MyTrait.html '//div[@id="associatedconstant.VALUE-4"]' '' type Assoc = bool; fn trait_function(&self) {} } diff --git a/src/test/rustdoc/trait-impl.rs b/src/test/rustdoc/trait-impl.rs index 4f7e2dfe3b9..4d5173f6024 100644 --- a/src/test/rustdoc/trait-impl.rs +++ b/src/test/rustdoc/trait-impl.rs @@ -40,7 +40,7 @@ impl Trait for Struct { fn c() {} // @has - '//*[@id="method.d"]/../../div[@class="docblock"]/p' 'Escaped formatting a*b*c* works' - // @!has - '//*[@id="method.d"]/../../div[@class="docblock"]/p/em' + // @!has - '//*[@id="method.d"]/../../div[@class="docblock"]/p/em' '' fn d() {} // @has - '//*[@id="impl-Trait-for-Struct"]/h3//a/@href' 'trait.Trait.html' diff --git a/src/test/rustdoc/tuple-struct-fields-doc.rs b/src/test/rustdoc/tuple-struct-fields-doc.rs index 31426131bc2..66bb409325c 100644 --- a/src/test/rustdoc/tuple-struct-fields-doc.rs +++ b/src/test/rustdoc/tuple-struct-fields-doc.rs @@ -5,7 +5,7 @@ // @has - '//h3[@class="sidebar-title"]/a[@href="#fields"]' 'Tuple Fields' // @has - '//*[@id="structfield.0"]' '0: u32' // @has - '//*[@id="main-content"]/div[@class="docblock"]' 'hello' -// @!has - '//*[@id="structfield.1"]' +// @!has - '//*[@id="structfield.1"]' '' // @has - '//*[@id="structfield.2"]' '2: char' // @has - '//*[@id="structfield.3"]' '3: i8' // @has - '//*[@id="main-content"]/div[@class="docblock"]' 'not hello' diff --git a/src/test/rustdoc/type-layout-flag-required.rs b/src/test/rustdoc/type-layout-flag-required.rs index a01fbd22950..6bb5e10f881 100644 --- a/src/test/rustdoc/type-layout-flag-required.rs +++ b/src/test/rustdoc/type-layout-flag-required.rs @@ -1,4 +1,4 @@ // Tests that `--show-type-layout` is required in order to show layout info. -// @!has type_layout_flag_required/struct.Foo.html 'Size: ' +// @!hasraw type_layout_flag_required/struct.Foo.html 'Size: ' pub struct Foo(usize); diff --git a/src/test/rustdoc/type-layout.rs b/src/test/rustdoc/type-layout.rs index e5c6e9dc3f9..5e0a0411a62 100644 --- a/src/test/rustdoc/type-layout.rs +++ b/src/test/rustdoc/type-layout.rs @@ -1,84 +1,84 @@ // compile-flags: --show-type-layout -Z unstable-options -// @has type_layout/struct.Foo.html 'Size: ' -// @has - ' bytes' +// @hasraw type_layout/struct.Foo.html 'Size: ' +// @hasraw - ' bytes' // @has - '//*[@id="layout"]/a[@href="#layout"]' '' pub struct Foo { pub a: usize, b: Vec<String>, } -// @has type_layout/enum.Bar.html 'Size: ' -// @has - ' bytes' +// @hasraw type_layout/enum.Bar.html 'Size: ' +// @hasraw - ' bytes' pub enum Bar<'a> { A(String), B(&'a str, (std::collections::HashMap<String, usize>, Foo)), } -// @has type_layout/union.Baz.html 'Size: ' -// @has - ' bytes' +// @hasraw type_layout/union.Baz.html 'Size: ' +// @hasraw - ' bytes' pub union Baz { a: &'static str, b: usize, c: &'static [u8], } -// @has type_layout/struct.X.html 'Size: ' -// @has - ' bytes' +// @hasraw type_layout/struct.X.html 'Size: ' +// @hasraw - ' bytes' pub struct X(usize); -// @has type_layout/struct.Y.html 'Size: ' -// @has - '1 byte' -// @!has - ' bytes' +// @hasraw type_layout/struct.Y.html 'Size: ' +// @hasraw - '1 byte' +// @!hasraw - ' bytes' pub struct Y(u8); -// @has type_layout/struct.Z.html 'Size: ' -// @has - '0 bytes' +// @hasraw type_layout/struct.Z.html 'Size: ' +// @hasraw - '0 bytes' pub struct Z; // We can't compute layout for generic types. -// @has type_layout/struct.Generic.html 'Unable to compute type layout, possibly due to this type having generic parameters' -// @!has - 'Size: ' +// @hasraw type_layout/struct.Generic.html 'Unable to compute type layout, possibly due to this type having generic parameters' +// @!hasraw - 'Size: ' pub struct Generic<T>(T); // We *can*, however, compute layout for types that are only generic over lifetimes, // because lifetimes are a type-system construct. -// @has type_layout/struct.GenericLifetimes.html 'Size: ' -// @has - ' bytes' +// @hasraw type_layout/struct.GenericLifetimes.html 'Size: ' +// @hasraw - ' bytes' pub struct GenericLifetimes<'a>(&'a str); -// @has type_layout/struct.Unsized.html 'Size: ' -// @has - '(unsized)' +// @hasraw type_layout/struct.Unsized.html 'Size: ' +// @hasraw - '(unsized)' pub struct Unsized([u8]); -// @has type_layout/type.TypeAlias.html 'Size: ' -// @has - ' bytes' +// @hasraw type_layout/type.TypeAlias.html 'Size: ' +// @hasraw - ' bytes' pub type TypeAlias = X; -// @has type_layout/type.GenericTypeAlias.html 'Size: ' -// @has - '8 bytes' +// @hasraw type_layout/type.GenericTypeAlias.html 'Size: ' +// @hasraw - '8 bytes' pub type GenericTypeAlias = (Generic<(u32, ())>, Generic<u32>); // Regression test for the rustdoc equivalent of #85103. -// @has type_layout/type.Edges.html 'Encountered an error during type layout; the type failed to be normalized.' +// @hasraw type_layout/type.Edges.html 'Encountered an error during type layout; the type failed to be normalized.' pub type Edges<'a, E> = std::borrow::Cow<'a, [E]>; -// @!has type_layout/trait.MyTrait.html 'Size: ' +// @!hasraw type_layout/trait.MyTrait.html 'Size: ' pub trait MyTrait {} -// @has type_layout/enum.Variants.html 'Size: ' -// @has - '2 bytes' -// @has - '<code>A</code>: 0 bytes' -// @has - '<code>B</code>: 1 byte' +// @hasraw type_layout/enum.Variants.html 'Size: ' +// @hasraw - '2 bytes' +// @hasraw - '<code>A</code>: 0 bytes' +// @hasraw - '<code>B</code>: 1 byte' pub enum Variants { A, B(u8), } -// @has type_layout/enum.WithNiche.html 'Size: ' +// @hasraw type_layout/enum.WithNiche.html 'Size: ' // @has - //p '4 bytes' -// @has - '<code>None</code>: 0 bytes' -// @has - '<code>Some</code>: 4 bytes' +// @hasraw - '<code>None</code>: 0 bytes' +// @hasraw - '<code>Some</code>: 4 bytes' pub enum WithNiche { None, Some(std::num::NonZeroU32), diff --git a/src/test/rustdoc/typedef.rs b/src/test/rustdoc/typedef.rs index 4ecd62cded2..b68ec4557ad 100644 --- a/src/test/rustdoc/typedef.rs +++ b/src/test/rustdoc/typedef.rs @@ -11,7 +11,7 @@ impl MyStruct { // @has typedef/type.MyAlias.html // @has - '//*[@class="impl has-srclink"]//h3[@class="code-header in-band"]' 'impl MyAlias' // @has - '//*[@class="impl has-srclink"]//h3[@class="code-header in-band"]' 'impl MyTrait for MyAlias' -// @has - 'Alias docstring' +// @hasraw - 'Alias docstring' // @has - '//*[@class="sidebar"]//*[@class="location"]' 'MyAlias' // @has - '//*[@class="sidebar"]//a[@href="#implementations"]' 'Methods' // @has - '//*[@class="sidebar"]//a[@href="#trait-implementations"]' 'Trait Implementations' diff --git a/src/test/rustdoc/universal-impl-trait.rs b/src/test/rustdoc/universal-impl-trait.rs index b10b1b8658d..f5eabda59b7 100644 --- a/src/test/rustdoc/universal-impl-trait.rs +++ b/src/test/rustdoc/universal-impl-trait.rs @@ -5,15 +5,15 @@ use std::borrow::Borrow; // @has foo/fn.foo.html // @has - //pre 'foo(' -// @matches - '_x: impl <a class="trait" href="[^"]+/trait\.Clone\.html"' -// @matches - '_z: .+impl.+trait\.Copy\.html.+, impl.+trait\.Clone\.html' +// @matchesraw - '_x: impl <a class="trait" href="[^"]+/trait\.Clone\.html"' +// @matchesraw - '_z: .+impl.+trait\.Copy\.html.+, impl.+trait\.Clone\.html' pub fn foo(_x: impl Clone, _y: i32, _z: (impl Copy, impl Clone)) { } pub trait Trait { // @has foo/trait.Trait.html - // @has - 'method</a>(' - // @matches - '_x: impl <a class="trait" href="[^"]+/trait\.Debug\.html"' + // @hasraw - 'method</a>(' + // @matchesraw - '_x: impl <a class="trait" href="[^"]+/trait\.Debug\.html"' fn method(&self, _x: impl std::fmt::Debug) { } } @@ -22,30 +22,30 @@ pub struct S<T>(T); impl<T> S<T> { // @has foo/struct.S.html - // @has - 'bar</a>(' - // @matches - '_bar: impl <a class="trait" href="[^"]+/trait\.Copy\.html"' + // @hasraw - 'bar</a>(' + // @matchesraw - '_bar: impl <a class="trait" href="[^"]+/trait\.Copy\.html"' pub fn bar(_bar: impl Copy) { } - // @has - 'baz</a>(' - // @matches - '_baz:.+struct\.S\.html.+impl .+trait\.Clone\.html' + // @hasraw - 'baz</a>(' + // @matchesraw - '_baz:.+struct\.S\.html.+impl .+trait\.Clone\.html' pub fn baz(_baz: S<impl Clone>) { } - // @has - 'qux</a>(' - // @matches - 'trait\.Read\.html' + // @hasraw - 'qux</a>(' + // @matchesraw - 'trait\.Read\.html' pub fn qux(_qux: impl IntoIterator<Item = S<impl Read>>) { } } -// @has - 'method</a>(' -// @matches - '_x: impl <a class="trait" href="[^"]+/trait\.Debug\.html"' +// @hasraw - 'method</a>(' +// @matchesraw - '_x: impl <a class="trait" href="[^"]+/trait\.Debug\.html"' impl<T> Trait for S<T> {} // @has foo/fn.much_universe.html -// @matches - 'T:.+Borrow.+impl .+trait\.Trait\.html' -// @matches - 'U:.+IntoIterator.+= impl.+Iterator\.html.+= impl.+Clone\.html' -// @matches - '_: impl .+trait\.Read\.html.+ \+ .+trait\.Clone\.html' +// @matchesraw - 'T:.+Borrow.+impl .+trait\.Trait\.html' +// @matchesraw - 'U:.+IntoIterator.+= impl.+Iterator\.html.+= impl.+Clone\.html' +// @matchesraw - '_: impl .+trait\.Read\.html.+ \+ .+trait\.Clone\.html' pub fn much_universe< T: Borrow<impl Trait>, U: IntoIterator<Item = impl Iterator<Item = impl Clone>>, diff --git a/src/test/ui/argument-suggestions/invalid_arguments.stderr b/src/test/ui/argument-suggestions/invalid_arguments.stderr index 33f27d48fec..303f0869578 100644 --- a/src/test/ui/argument-suggestions/invalid_arguments.stderr +++ b/src/test/ui/argument-suggestions/invalid_arguments.stderr @@ -24,7 +24,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:6:4 | LL | fn two_arg_same(_a: i32, _b: i32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^^^^^^^^^^^ ------- error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:17:16 @@ -38,7 +38,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:6:4 | LL | fn two_arg_same(_a: i32, _b: i32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^^^^^^^^^^^ ------- error[E0308]: arguments to this function are incorrect --> $DIR/invalid_arguments.rs:18:3 @@ -66,7 +66,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:7:4 | LL | fn two_arg_diff(_a: i32, _b: f32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^^^^^^^^^^^ ------- error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:20:16 @@ -80,7 +80,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:7:4 | LL | fn two_arg_diff(_a: i32, _b: f32) {} - | ^^^^^^^^^^^^ ------- ------- + | ^^^^^^^^^^^^ ------- error[E0308]: arguments to this function are incorrect --> $DIR/invalid_arguments.rs:21:3 @@ -108,7 +108,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:8:4 | LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^^^^^^^^^^^ ------- error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:25:21 @@ -122,7 +122,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:8:4 | LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^^^^^^^^^^^ ------- error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:26:26 @@ -136,7 +136,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:8:4 | LL | fn three_arg_diff(_a: i32, _b: f32, _c: &str) {} - | ^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^^^^^^^^^^^ -------- error[E0308]: arguments to this function are incorrect --> $DIR/invalid_arguments.rs:28:3 @@ -207,7 +207,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:9:4 | LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^^^^^^^^^^^^^ ------- error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:35:23 @@ -221,7 +221,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:9:4 | LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^^^^^^^^^^^^^ ------- error[E0308]: mismatched types --> $DIR/invalid_arguments.rs:36:26 @@ -235,7 +235,7 @@ note: function defined here --> $DIR/invalid_arguments.rs:9:4 | LL | fn three_arg_repeat(_a: i32, _b: i32, _c: &str) {} - | ^^^^^^^^^^^^^^^^ ------- ------- -------- + | ^^^^^^^^^^^^^^^^ -------- error[E0308]: arguments to this function are incorrect --> $DIR/invalid_arguments.rs:38:3 diff --git a/src/test/ui/argument-suggestions/issue-96638.stderr b/src/test/ui/argument-suggestions/issue-96638.stderr index 8af31b8b751..804cb1aa322 100644 --- a/src/test/ui/argument-suggestions/issue-96638.stderr +++ b/src/test/ui/argument-suggestions/issue-96638.stderr @@ -2,7 +2,9 @@ error[E0061]: this function takes 3 arguments but 2 arguments were supplied --> $DIR/issue-96638.rs:8:5 | LL | f(&x, ""); - | ^ -- an argument of type `usize` is missing + | ^ -- -- expected `usize`, found `&str` + | | + | an argument of type `usize` is missing | note: function defined here --> $DIR/issue-96638.rs:1:4 diff --git a/src/test/ui/argument-suggestions/issue-97484.stderr b/src/test/ui/argument-suggestions/issue-97484.stderr index 9589e919c0a..b5dedf0f4fa 100644 --- a/src/test/ui/argument-suggestions/issue-97484.stderr +++ b/src/test/ui/argument-suggestions/issue-97484.stderr @@ -2,8 +2,9 @@ error[E0061]: this function takes 4 arguments but 7 arguments were supplied --> $DIR/issue-97484.rs:12:5 | LL | foo(&&A, B, C, D, E, F, G); - | ^^^ - - - argument of type `F` unexpected - | | | + | ^^^ - - - - argument of type `F` unexpected + | | | | + | | | expected `&E`, found struct `E` | | argument of type `C` unexpected | argument of type `B` unexpected | diff --git a/src/test/ui/argument-suggestions/too-long.rs b/src/test/ui/argument-suggestions/too-long.rs new file mode 100644 index 00000000000..7ec56afae1c --- /dev/null +++ b/src/test/ui/argument-suggestions/too-long.rs @@ -0,0 +1,41 @@ +struct Qux; + +impl Qux { + fn foo( + &self, + a: i32, + b: i32, + c: i32, + d: i32, + e: i32, + f: i32, + g: i32, + h: i32, + i: i32, + j: i32, + k: i32, + l: i32, + ) { + } +} + +fn what( + qux: &Qux, + a: i32, + b: i32, + c: i32, + d: i32, + e: i32, + f: &i32, + g: i32, + h: i32, + i: i32, + j: i32, + k: i32, + l: i32, +) { + qux.foo(a, b, c, d, e, f, g, h, i, j, k, l); + //~^ ERROR mismatched types +} + +fn main() {} diff --git a/src/test/ui/argument-suggestions/too-long.stderr b/src/test/ui/argument-suggestions/too-long.stderr new file mode 100644 index 00000000000..bd430194c5e --- /dev/null +++ b/src/test/ui/argument-suggestions/too-long.stderr @@ -0,0 +1,24 @@ +error[E0308]: mismatched types + --> $DIR/too-long.rs:37:28 + | +LL | qux.foo(a, b, c, d, e, f, g, h, i, j, k, l); + | --- ^ expected `i32`, found `&i32` + | | + | arguments to this function are incorrect + | +note: associated function defined here + --> $DIR/too-long.rs:4:8 + | +LL | fn foo( + | ^^^ +... +LL | f: i32, + | ------ +help: consider dereferencing the borrow + | +LL | qux.foo(a, b, c, d, e, *f, g, h, i, j, k, l); + | + + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/argument-suggestions/two-mismatch-notes.rs b/src/test/ui/argument-suggestions/two-mismatch-notes.rs new file mode 100644 index 00000000000..1309041ab9a --- /dev/null +++ b/src/test/ui/argument-suggestions/two-mismatch-notes.rs @@ -0,0 +1,11 @@ +#[derive(Copy, Clone)] +struct Wrapper<T>(T); + +fn foo(_: fn(i32), _: Wrapper<i32>) {} + +fn f(_: u32) {} + +fn main() { + let w = Wrapper::<isize>(1isize); + foo(f, w); //~ ERROR arguments to this function are incorrect +} diff --git a/src/test/ui/argument-suggestions/two-mismatch-notes.stderr b/src/test/ui/argument-suggestions/two-mismatch-notes.stderr new file mode 100644 index 00000000000..7873cf964cb --- /dev/null +++ b/src/test/ui/argument-suggestions/two-mismatch-notes.stderr @@ -0,0 +1,29 @@ +error[E0308]: arguments to this function are incorrect + --> $DIR/two-mismatch-notes.rs:10:5 + | +LL | foo(f, w); + | ^^^ + | +note: expected `i32`, found `u32` + --> $DIR/two-mismatch-notes.rs:10:9 + | +LL | foo(f, w); + | ^ + = note: expected fn pointer `fn(i32)` + found fn item `fn(u32) {f}` +note: expected `i32`, found `isize` + --> $DIR/two-mismatch-notes.rs:10:12 + | +LL | foo(f, w); + | ^ + = note: expected struct `Wrapper<i32>` + found struct `Wrapper<isize>` +note: function defined here + --> $DIR/two-mismatch-notes.rs:4:4 + | +LL | fn foo(_: fn(i32), _: Wrapper<i32>) {} + | ^^^ ---------- --------------- + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr b/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr index b904ad102e9..e761c6c62a6 100644 --- a/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr +++ b/src/test/ui/associated-types/associated-type-projection-from-supertrait.stderr @@ -10,7 +10,7 @@ note: function defined here --> $DIR/associated-type-projection-from-supertrait.rs:25:4 | LL | fn dent<C:Car>(c: C, color: C::Color) { c.chip_paint(color) } - | ^^^^ ---- --------------- + | ^^^^ --------------- error[E0308]: mismatched types --> $DIR/associated-type-projection-from-supertrait.rs:28:23 @@ -24,7 +24,7 @@ note: function defined here --> $DIR/associated-type-projection-from-supertrait.rs:25:4 | LL | fn dent<C:Car>(c: C, color: C::Color) { c.chip_paint(color) } - | ^^^^ ---- --------------- + | ^^^^ --------------- error[E0308]: mismatched types --> $DIR/associated-type-projection-from-supertrait.rs:32:28 @@ -38,7 +38,7 @@ note: associated function defined here --> $DIR/associated-type-projection-from-supertrait.rs:12:8 | LL | fn chip_paint(&self, c: Self::Color) { } - | ^^^^^^^^^^ ----- -------------- + | ^^^^^^^^^^ -------------- error[E0308]: mismatched types --> $DIR/associated-type-projection-from-supertrait.rs:33:28 @@ -52,7 +52,7 @@ note: associated function defined here --> $DIR/associated-type-projection-from-supertrait.rs:12:8 | LL | fn chip_paint(&self, c: Self::Color) { } - | ^^^^^^^^^^ ----- -------------- + | ^^^^^^^^^^ -------------- error: aborting due to 4 previous errors diff --git a/src/test/ui/associated-types/associated-types-path-2.stderr b/src/test/ui/associated-types/associated-types-path-2.stderr index 1d0b84d31d4..c37d469890c 100644 --- a/src/test/ui/associated-types/associated-types-path-2.stderr +++ b/src/test/ui/associated-types/associated-types-path-2.stderr @@ -10,7 +10,7 @@ note: function defined here --> $DIR/associated-types-path-2.rs:13:8 | LL | pub fn f1<T: Foo>(a: T, x: T::A) {} - | ^^ ---- ------- + | ^^ ------- help: change the type of the numeric literal from `i32` to `u32` | LL | f1(2i32, 4u32); diff --git a/src/test/ui/associated-types/issue-22560.stderr b/src/test/ui/associated-types/issue-22560.stderr index 700923c1b3f..2b88cf0b441 100644 --- a/src/test/ui/associated-types/issue-22560.stderr +++ b/src/test/ui/associated-types/issue-22560.stderr @@ -1,25 +1,3 @@ -error[E0393]: the type parameter `Rhs` must be explicitly specified - --> $DIR/issue-22560.rs:9:23 - | -LL | trait Sub<Rhs=Self> { - | ------------------- type parameter `Rhs` must be specified for this -... -LL | type Test = dyn Add + Sub; - | ^^^ help: set the type parameter to the desired type: `Sub<Rhs>` - | - = note: because of the default `Self` reference, type parameters must be specified on object types - -error[E0393]: the type parameter `Rhs` must be explicitly specified - --> $DIR/issue-22560.rs:9:17 - | -LL | trait Add<Rhs=Self> { - | ------------------- type parameter `Rhs` must be specified for this -... -LL | type Test = dyn Add + Sub; - | ^^^ help: set the type parameter to the desired type: `Add<Rhs>` - | - = note: because of the default `Self` reference, type parameters must be specified on object types - error[E0225]: only auto traits can be used as additional traits in a trait object --> $DIR/issue-22560.rs:9:23 | @@ -28,7 +6,7 @@ LL | type Test = dyn Add + Sub; | | | first non-auto trait | - = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Add<[type error]> + Sub<[type error]> {}` + = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Add + Sub {}` = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> error[E0191]: the value of the associated types `Output` (from trait `Add`), `Output` (from trait `Sub`) must be specified @@ -50,6 +28,28 @@ help: specify the associated types LL | type Test = dyn Add<Output = Type> + Sub<Output = Type>; | ~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~ +error[E0393]: the type parameter `Rhs` must be explicitly specified + --> $DIR/issue-22560.rs:9:17 + | +LL | trait Add<Rhs=Self> { + | ------------------- type parameter `Rhs` must be specified for this +... +LL | type Test = dyn Add + Sub; + | ^^^ help: set the type parameter to the desired type: `Add<Rhs>` + | + = note: because of the default `Self` reference, type parameters must be specified on object types + +error[E0393]: the type parameter `Rhs` must be explicitly specified + --> $DIR/issue-22560.rs:9:23 + | +LL | trait Sub<Rhs=Self> { + | ------------------- type parameter `Rhs` must be specified for this +... +LL | type Test = dyn Add + Sub; + | ^^^ help: set the type parameter to the desired type: `Sub<Rhs>` + | + = note: because of the default `Self` reference, type parameters must be specified on object types + error: aborting due to 4 previous errors Some errors have detailed explanations: E0191, E0225, E0393. diff --git a/src/test/ui/async-await/generator-desc.stderr b/src/test/ui/async-await/generator-desc.stderr index 3be8c552063..2494c3feb2a 100644 --- a/src/test/ui/async-await/generator-desc.stderr +++ b/src/test/ui/async-await/generator-desc.stderr @@ -42,7 +42,7 @@ note: function defined here --> $DIR/generator-desc.rs:8:4 | LL | fn fun<F: Future<Output = ()>>(f1: F, f2: F) {} - | ^^^ ----- ----- + | ^^^ ----- error[E0308]: mismatched types --> $DIR/generator-desc.rs:14:26 @@ -67,7 +67,7 @@ note: function defined here --> $DIR/generator-desc.rs:8:4 | LL | fn fun<F: Future<Output = ()>>(f1: F, f2: F) {} - | ^^^ ----- ----- + | ^^^ ----- error: aborting due to 3 previous errors diff --git a/src/test/ui/closures/binder/disallow-const.rs b/src/test/ui/closures/binder/disallow-const.rs new file mode 100644 index 00000000000..72ad6185d37 --- /dev/null +++ b/src/test/ui/closures/binder/disallow-const.rs @@ -0,0 +1,6 @@ +#![feature(closure_lifetime_binder)] + +fn main() { + for<const N: i32> || -> () {}; + //~^ ERROR only lifetime parameters can be used in this context +} diff --git a/src/test/ui/closures/binder/disallow-const.stderr b/src/test/ui/closures/binder/disallow-const.stderr new file mode 100644 index 00000000000..3c3b43d8cf3 --- /dev/null +++ b/src/test/ui/closures/binder/disallow-const.stderr @@ -0,0 +1,8 @@ +error: only lifetime parameters can be used in this context + --> $DIR/disallow-const.rs:4:15 + | +LL | for<const N: i32> || -> () {}; + | ^ + +error: aborting due to previous error + diff --git a/src/test/ui/closures/binder/disallow-ty.rs b/src/test/ui/closures/binder/disallow-ty.rs new file mode 100644 index 00000000000..bbe3d8488d9 --- /dev/null +++ b/src/test/ui/closures/binder/disallow-ty.rs @@ -0,0 +1,6 @@ +#![feature(closure_lifetime_binder)] + +fn main() { + for<T> || -> () {}; + //~^ ERROR only lifetime parameters can be used in this context +} diff --git a/src/test/ui/closures/binder/disallow-ty.stderr b/src/test/ui/closures/binder/disallow-ty.stderr new file mode 100644 index 00000000000..51b6773edea --- /dev/null +++ b/src/test/ui/closures/binder/disallow-ty.stderr @@ -0,0 +1,8 @@ +error: only lifetime parameters can be used in this context + --> $DIR/disallow-ty.rs:4:9 + | +LL | for<T> || -> () {}; + | ^ + +error: aborting due to previous error + diff --git a/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr b/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr index 36551e5afc6..5cbdef21831 100644 --- a/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr +++ b/src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr @@ -12,7 +12,7 @@ note: function defined here --> $DIR/coerce-reborrow-multi-arg-fail.rs:1:4 | LL | fn test<T>(_a: T, _b: T) {} - | ^^^^ ----- ----- + | ^^^^ ----- error: aborting due to previous error diff --git a/src/test/ui/coercion/coerce-to-bang.stderr b/src/test/ui/coercion/coerce-to-bang.stderr index add8f14cfa5..1207dc7e7a2 100644 --- a/src/test/ui/coercion/coerce-to-bang.stderr +++ b/src/test/ui/coercion/coerce-to-bang.stderr @@ -12,7 +12,7 @@ note: function defined here --> $DIR/coerce-to-bang.rs:3:4 | LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- + | ^^^ ---- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:18:13 @@ -28,7 +28,7 @@ note: function defined here --> $DIR/coerce-to-bang.rs:3:4 | LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- + | ^^^ ---- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:26:12 @@ -44,7 +44,7 @@ note: function defined here --> $DIR/coerce-to-bang.rs:3:4 | LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- + | ^^^ ---- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:36:12 @@ -60,7 +60,7 @@ note: function defined here --> $DIR/coerce-to-bang.rs:3:4 | LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- + | ^^^ ---- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:45:12 @@ -76,7 +76,7 @@ note: function defined here --> $DIR/coerce-to-bang.rs:3:4 | LL | fn foo(x: usize, y: !, z: usize) { } - | ^^^ -------- ---- -------- + | ^^^ ---- error[E0308]: mismatched types --> $DIR/coerce-to-bang.rs:50:21 diff --git a/src/test/ui/coherence/auxiliary/trait-with-const-param.rs b/src/test/ui/coherence/auxiliary/trait-with-const-param.rs new file mode 100644 index 00000000000..a44eb14f8e4 --- /dev/null +++ b/src/test/ui/coherence/auxiliary/trait-with-const-param.rs @@ -0,0 +1 @@ +pub trait Trait<const N: usize, T> {} diff --git a/src/test/ui/coherence/const-generics-orphan-check-ok.rs b/src/test/ui/coherence/const-generics-orphan-check-ok.rs new file mode 100644 index 00000000000..217e8aed234 --- /dev/null +++ b/src/test/ui/coherence/const-generics-orphan-check-ok.rs @@ -0,0 +1,28 @@ +// check-pass +// aux-build:trait-with-const-param.rs +extern crate trait_with_const_param; +use trait_with_const_param::*; + +// Trivial case, const param after local type. +struct Local1; +impl<const N: usize, T> Trait<N, T> for Local1 {} + +// Concrete consts behave the same as foreign types, +// so this also trivially works. +impl Trait<3, Local1> for i32 {} + +// This case isn't as trivial as we would forbid type +// parameters here, we do allow const parameters though. +// +// The reason that type parameters are forbidden for +// `impl<T> Trait<T, LocalInA> for i32 {}` is that another +// downstream crate can add `impl<T> Trait<LocalInB, T> for i32`. +// As these two impls would overlap we forbid any impls which +// have a type parameter in front of a local type. +// +// With const parameters this issue does not exist as there are no +// constants local to another downstream crate. +struct Local2; +impl<const N: usize> Trait<N, Local2> for i32 {} + +fn main() {} diff --git a/src/test/ui/const-generics/generic_const_exprs/issue-100360.rs b/src/test/ui/const-generics/generic_const_exprs/issue-100360.rs new file mode 100644 index 00000000000..5572f1f88df --- /dev/null +++ b/src/test/ui/const-generics/generic_const_exprs/issue-100360.rs @@ -0,0 +1,13 @@ +// check-pass +// (this requires debug assertions) + +#![feature(adt_const_params)] +#![allow(incomplete_features)] + +fn foo<const B: &'static bool>(arg: &'static bool) -> bool { + B == arg +} + +fn main() { + foo::<{ &true }>(&false); +} diff --git a/src/test/ui/const-generics/generic_const_exprs/issue-89851.rs b/src/test/ui/const-generics/generic_const_exprs/issue-89851.rs new file mode 100644 index 00000000000..cde849d9017 --- /dev/null +++ b/src/test/ui/const-generics/generic_const_exprs/issue-89851.rs @@ -0,0 +1,12 @@ +// check-pass +// (this requires debug assertions) + +#![feature(adt_const_params)] +#![allow(incomplete_features)] + +pub const BAR: () = ice::<"">(); +pub const fn ice<const N: &'static str>() { + &10; +} + +fn main() {} diff --git a/src/test/ui/consts/extra-const-ub/detect-extra-ub.rs b/src/test/ui/consts/extra-const-ub/detect-extra-ub.rs new file mode 100644 index 00000000000..97c9e150519 --- /dev/null +++ b/src/test/ui/consts/extra-const-ub/detect-extra-ub.rs @@ -0,0 +1,45 @@ +// revisions: no_flag with_flag +// [no_flag] check-pass +// [with_flag] compile-flags: -Zextra-const-ub-checks +#![feature(const_ptr_read)] + +use std::mem::transmute; + +const INVALID_BOOL: () = unsafe { + let _x: bool = transmute(3u8); + //[with_flag]~^ ERROR: evaluation of constant value failed + //[with_flag]~| invalid value +}; + +const INVALID_PTR_IN_INT: () = unsafe { + let _x: usize = transmute(&3u8); + //[with_flag]~^ ERROR: evaluation of constant value failed + //[with_flag]~| invalid value +}; + +const INVALID_SLICE_TO_USIZE_TRANSMUTE: () = unsafe { + let x: &[u8] = &[0; 32]; + let _x: (usize, usize) = transmute(x); + //[with_flag]~^ ERROR: evaluation of constant value failed + //[with_flag]~| invalid value +}; + +const UNALIGNED_PTR: () = unsafe { + let _x: &u32 = transmute(&[0u8; 4]); + //[with_flag]~^ ERROR: evaluation of constant value failed + //[with_flag]~| invalid value +}; + +const UNALIGNED_READ: () = { + INNER; //[with_flag]~ERROR any use of this value will cause an error + //[with_flag]~| previously accepted + // There is an error here but its span is in the standard library so we cannot match it... + // so we have this in a *nested* const, such that the *outer* const fails to use it. + const INNER: () = unsafe { + let x = &[0u8; 4]; + let ptr = x.as_ptr().cast::<u32>(); + ptr.read(); + }; +}; + +fn main() {} diff --git a/src/test/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr b/src/test/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr new file mode 100644 index 00000000000..1706db7ac43 --- /dev/null +++ b/src/test/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr @@ -0,0 +1,71 @@ +error[E0080]: evaluation of constant value failed + --> $DIR/detect-extra-ub.rs:9:20 + | +LL | let _x: bool = transmute(3u8); + | ^^^^^^^^^^^^^^ constructing invalid value: encountered 0x03, but expected a boolean + +error[E0080]: evaluation of constant value failed + --> $DIR/detect-extra-ub.rs:15:21 + | +LL | let _x: usize = transmute(&3u8); + | ^^^^^^^^^^^^^^^ constructing invalid value: encountered (potentially part of) a pointer, but expected plain (non-pointer) bytes + +error[E0080]: evaluation of constant value failed + --> $DIR/detect-extra-ub.rs:22:30 + | +LL | let _x: (usize, usize) = transmute(x); + | ^^^^^^^^^^^^ constructing invalid value at .0: encountered (potentially part of) a pointer, but expected plain (non-pointer) bytes + +error[E0080]: evaluation of constant value failed + --> $DIR/detect-extra-ub.rs:28:20 + | +LL | let _x: &u32 = transmute(&[0u8; 4]); + | ^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered an unaligned reference (required 4 byte alignment but found 1) + +error[E0080]: evaluation of constant value failed + --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL + | +LL | copy_nonoverlapping(src, tmp.as_mut_ptr(), 1); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | accessing memory with alignment 1, but alignment 4 is required + | inside `std::ptr::read::<u32>` at $SRC_DIR/core/src/ptr/mod.rs:LL:COL + | + ::: $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL + | +LL | unsafe { read(self) } + | ---------- inside `ptr::const_ptr::<impl *const u32>::read` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL + | + ::: $DIR/detect-extra-ub.rs:41:9 + | +LL | ptr.read(); + | ---------- inside `INNER` at $DIR/detect-extra-ub.rs:41:9 + +error: any use of this value will cause an error + --> $DIR/detect-extra-ub.rs:34:5 + | +LL | const UNALIGNED_READ: () = { + | ------------------------ +LL | INNER; + | ^^^^^ referenced constant has errors + | + = note: `#[deny(const_err)]` on by default + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800> + +error: aborting due to 6 previous errors + +For more information about this error, try `rustc --explain E0080`. +Future incompatibility report: Future breakage diagnostic: +error: any use of this value will cause an error + --> $DIR/detect-extra-ub.rs:34:5 + | +LL | const UNALIGNED_READ: () = { + | ------------------------ +LL | INNER; + | ^^^^^ referenced constant has errors + | + = note: `#[deny(const_err)]` on by default + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800> + diff --git a/src/test/ui/cycle-trait/cycle-trait-default-type-trait.rs b/src/test/ui/cycle-trait/cycle-trait-default-type-trait.rs index b2edc1a1f66..6175b7df110 100644 --- a/src/test/ui/cycle-trait/cycle-trait-default-type-trait.rs +++ b/src/test/ui/cycle-trait/cycle-trait-default-type-trait.rs @@ -3,7 +3,6 @@ trait Foo<X = Box<dyn Foo>> { //~^ ERROR cycle detected - //~| ERROR cycle detected } fn main() { } diff --git a/src/test/ui/cycle-trait/cycle-trait-default-type-trait.stderr b/src/test/ui/cycle-trait/cycle-trait-default-type-trait.stderr index d4976a0f9c9..9d715f49471 100644 --- a/src/test/ui/cycle-trait/cycle-trait-default-type-trait.stderr +++ b/src/test/ui/cycle-trait/cycle-trait-default-type-trait.stderr @@ -10,30 +10,11 @@ note: cycle used when collecting item types in top-level module | LL | / trait Foo<X = Box<dyn Foo>> { LL | | -LL | | -LL | | } -LL | | -LL | | fn main() { } - | |_____________^ - -error[E0391]: cycle detected when computing type of `Foo::X` - --> $DIR/cycle-trait-default-type-trait.rs:4:23 - | -LL | trait Foo<X = Box<dyn Foo>> { - | ^^^ - | - = note: ...which immediately requires computing type of `Foo::X` again -note: cycle used when collecting item types in top-level module - --> $DIR/cycle-trait-default-type-trait.rs:4:1 - | -LL | / trait Foo<X = Box<dyn Foo>> { -LL | | -LL | | LL | | } LL | | LL | | fn main() { } | |_____________^ -error: aborting due to 2 previous errors +error: aborting due to previous error For more information about this error, try `rustc --explain E0391`. diff --git a/src/test/ui/fn/fn-item-type.stderr b/src/test/ui/fn/fn-item-type.stderr index ecc6485d6d2..f03a47d5c2c 100644 --- a/src/test/ui/fn/fn-item-type.stderr +++ b/src/test/ui/fn/fn-item-type.stderr @@ -15,7 +15,7 @@ note: function defined here --> $DIR/fn-item-type.rs:7:4 | LL | fn eq<T>(x: T, y: T) { } - | ^^ ---- ---- + | ^^ ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:22:19 @@ -34,7 +34,7 @@ note: function defined here --> $DIR/fn-item-type.rs:7:4 | LL | fn eq<T>(x: T, y: T) { } - | ^^ ---- ---- + | ^^ ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:29:23 @@ -53,7 +53,7 @@ note: function defined here --> $DIR/fn-item-type.rs:7:4 | LL | fn eq<T>(x: T, y: T) { } - | ^^ ---- ---- + | ^^ ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:38:26 @@ -72,7 +72,7 @@ note: function defined here --> $DIR/fn-item-type.rs:7:4 | LL | fn eq<T>(x: T, y: T) { } - | ^^ ---- ---- + | ^^ ---- error[E0308]: mismatched types --> $DIR/fn-item-type.rs:45:19 @@ -90,7 +90,7 @@ note: function defined here --> $DIR/fn-item-type.rs:7:4 | LL | fn eq<T>(x: T, y: T) { } - | ^^ ---- ---- + | ^^ ---- error: aborting due to 5 previous errors diff --git a/src/test/ui/hrtb/complex.rs b/src/test/ui/higher-rank-trait-bounds/complex.rs index 8cdfe247e02..8cdfe247e02 100644 --- a/src/test/ui/hrtb/complex.rs +++ b/src/test/ui/higher-rank-trait-bounds/complex.rs diff --git a/src/test/ui/hrtb/due-to-where-clause.rs b/src/test/ui/higher-rank-trait-bounds/due-to-where-clause.rs index 1afd15613b5..1afd15613b5 100644 --- a/src/test/ui/hrtb/due-to-where-clause.rs +++ b/src/test/ui/higher-rank-trait-bounds/due-to-where-clause.rs diff --git a/src/test/ui/hrtb/due-to-where-clause.stderr b/src/test/ui/higher-rank-trait-bounds/due-to-where-clause.stderr index 520938a6335..520938a6335 100644 --- a/src/test/ui/hrtb/due-to-where-clause.stderr +++ b/src/test/ui/higher-rank-trait-bounds/due-to-where-clause.stderr diff --git a/src/test/ui/hrtb/hrtb-cache-issue-54302.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.rs index a20d03c7747..a20d03c7747 100644 --- a/src/test/ui/hrtb/hrtb-cache-issue-54302.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.rs diff --git a/src/test/ui/hrtb/hrtb-cache-issue-54302.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.stderr index f014eab8601..f014eab8601 100644 --- a/src/test/ui/hrtb/hrtb-cache-issue-54302.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.stderr diff --git a/src/test/ui/hrtb/hrtb-conflate-regions.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-conflate-regions.rs index e83686404a3..e83686404a3 100644 --- a/src/test/ui/hrtb/hrtb-conflate-regions.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-conflate-regions.rs diff --git a/src/test/ui/hrtb/hrtb-conflate-regions.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-conflate-regions.stderr index 46f5308dd87..46f5308dd87 100644 --- a/src/test/ui/hrtb/hrtb-conflate-regions.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-conflate-regions.stderr diff --git a/src/test/ui/hrtb/hrtb-debruijn-in-receiver.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.rs index 05d3e1a434e..05d3e1a434e 100644 --- a/src/test/ui/hrtb/hrtb-debruijn-in-receiver.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.rs diff --git a/src/test/ui/hrtb/hrtb-debruijn-in-receiver.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.stderr index fa391ecba8a..fa391ecba8a 100644 --- a/src/test/ui/hrtb/hrtb-debruijn-in-receiver.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.stderr diff --git a/src/test/ui/hrtb/hrtb-exists-forall-fn.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.rs index 56780237618..56780237618 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-fn.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.rs diff --git a/src/test/ui/hrtb/hrtb-exists-forall-fn.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.stderr index 9914783d976..9914783d976 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-fn.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.stderr diff --git a/src/test/ui/hrtb/hrtb-exists-forall-trait-contravariant.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.rs index 921061916fc..921061916fc 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-trait-contravariant.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.rs diff --git a/src/test/ui/hrtb/hrtb-exists-forall-trait-contravariant.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.stderr index 364b613fc77..364b613fc77 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-trait-contravariant.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.stderr diff --git a/src/test/ui/hrtb/hrtb-exists-forall-trait-covariant.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-covariant.rs index f95496a6c3c..f95496a6c3c 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-trait-covariant.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-covariant.rs diff --git a/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.rs index 9b9e4496a87..9b9e4496a87 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.rs diff --git a/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.stderr index cb2ce8a4116..cb2ce8a4116 100644 --- a/src/test/ui/hrtb/hrtb-exists-forall-trait-invariant.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.stderr diff --git a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits-transitive.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.rs index f9ae1429ee4..f9ae1429ee4 100644 --- a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits-transitive.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.rs diff --git a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits-transitive.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr index 8cda76b9490..8cda76b9490 100644 --- a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits-transitive.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr diff --git a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.rs index 48ebe5017aa..48ebe5017aa 100644 --- a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.rs diff --git a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.stderr index 88793a1525b..88793a1525b 100644 --- a/src/test/ui/hrtb/hrtb-higher-ranker-supertraits.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.stderr diff --git a/src/test/ui/hrtb/hrtb-identity-fn-borrows.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.rs index 89fc4705a78..89fc4705a78 100644 --- a/src/test/ui/hrtb/hrtb-identity-fn-borrows.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.rs diff --git a/src/test/ui/hrtb/hrtb-identity-fn-borrows.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.stderr index 4886a3c8bad..4886a3c8bad 100644 --- a/src/test/ui/hrtb/hrtb-identity-fn-borrows.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.stderr diff --git a/src/test/ui/hrtb/hrtb-just-for-static.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-just-for-static.rs index 8fb4218f8a4..8fb4218f8a4 100644 --- a/src/test/ui/hrtb/hrtb-just-for-static.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-just-for-static.rs diff --git a/src/test/ui/hrtb/hrtb-just-for-static.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-just-for-static.stderr index b4312091edb..b4312091edb 100644 --- a/src/test/ui/hrtb/hrtb-just-for-static.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-just-for-static.stderr diff --git a/src/test/ui/hrtb/hrtb-perfect-forwarding.polonius.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.polonius.stderr index a94c80eb30b..a94c80eb30b 100644 --- a/src/test/ui/hrtb/hrtb-perfect-forwarding.polonius.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.polonius.stderr diff --git a/src/test/ui/hrtb/hrtb-perfect-forwarding.rs b/src/test/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.rs index d45fa183c0c..d45fa183c0c 100644 --- a/src/test/ui/hrtb/hrtb-perfect-forwarding.rs +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.rs diff --git a/src/test/ui/hrtb/hrtb-perfect-forwarding.stderr b/src/test/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.stderr index 1461e7fd2dd..1461e7fd2dd 100644 --- a/src/test/ui/hrtb/hrtb-perfect-forwarding.stderr +++ b/src/test/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.stderr diff --git a/src/test/ui/hrtb/issue-30786.rs b/src/test/ui/higher-rank-trait-bounds/issue-30786.rs index e5f46f711c2..e5f46f711c2 100644 --- a/src/test/ui/hrtb/issue-30786.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-30786.rs diff --git a/src/test/ui/hrtb/issue-30786.stderr b/src/test/ui/higher-rank-trait-bounds/issue-30786.stderr index ffe3d7b81f5..ffe3d7b81f5 100644 --- a/src/test/ui/hrtb/issue-30786.stderr +++ b/src/test/ui/higher-rank-trait-bounds/issue-30786.stderr diff --git a/src/test/ui/hrtb/issue-46989.rs b/src/test/ui/higher-rank-trait-bounds/issue-46989.rs index 4a09f4be156..4a09f4be156 100644 --- a/src/test/ui/hrtb/issue-46989.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-46989.rs diff --git a/src/test/ui/hrtb/issue-46989.stderr b/src/test/ui/higher-rank-trait-bounds/issue-46989.stderr index 309e1a676ed..309e1a676ed 100644 --- a/src/test/ui/hrtb/issue-46989.stderr +++ b/src/test/ui/higher-rank-trait-bounds/issue-46989.stderr diff --git a/src/test/ui/hrtb/issue-57639.rs b/src/test/ui/higher-rank-trait-bounds/issue-57639.rs index 392e7233b56..392e7233b56 100644 --- a/src/test/ui/hrtb/issue-57639.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-57639.rs diff --git a/src/test/ui/hrtb/issue-58451.rs b/src/test/ui/higher-rank-trait-bounds/issue-58451.rs index f36d549e476..f36d549e476 100644 --- a/src/test/ui/hrtb/issue-58451.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-58451.rs diff --git a/src/test/ui/hrtb/issue-58451.stderr b/src/test/ui/higher-rank-trait-bounds/issue-58451.stderr index 22ba63c3e86..22ba63c3e86 100644 --- a/src/test/ui/hrtb/issue-58451.stderr +++ b/src/test/ui/higher-rank-trait-bounds/issue-58451.stderr diff --git a/src/test/ui/hrtb/issue-62203-hrtb-ice.rs b/src/test/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.rs index ae21dbce011..ae21dbce011 100644 --- a/src/test/ui/hrtb/issue-62203-hrtb-ice.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.rs diff --git a/src/test/ui/hrtb/issue-62203-hrtb-ice.stderr b/src/test/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.stderr index 8365fd0c79e..8365fd0c79e 100644 --- a/src/test/ui/hrtb/issue-62203-hrtb-ice.stderr +++ b/src/test/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.stderr diff --git a/src/test/ui/hrtb/issue-88446.rs b/src/test/ui/higher-rank-trait-bounds/issue-88446.rs index 571b8531757..571b8531757 100644 --- a/src/test/ui/hrtb/issue-88446.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-88446.rs diff --git a/src/test/ui/hrtb/issue-90177.rs b/src/test/ui/higher-rank-trait-bounds/issue-90177.rs index b151a9d3ab6..b151a9d3ab6 100644 --- a/src/test/ui/hrtb/issue-90177.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-90177.rs diff --git a/src/test/ui/hrtb/issue-95034.rs b/src/test/ui/higher-rank-trait-bounds/issue-95034.rs index d8edbe7e56b..d8edbe7e56b 100644 --- a/src/test/ui/hrtb/issue-95034.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-95034.rs diff --git a/src/test/ui/hrtb/issue-95034.stderr b/src/test/ui/higher-rank-trait-bounds/issue-95034.stderr index 1d8329142fc..1d8329142fc 100644 --- a/src/test/ui/hrtb/issue-95034.stderr +++ b/src/test/ui/higher-rank-trait-bounds/issue-95034.stderr diff --git a/src/test/ui/hrtb/issue-95230.rs b/src/test/ui/higher-rank-trait-bounds/issue-95230.rs index 92c506eabb7..92c506eabb7 100644 --- a/src/test/ui/hrtb/issue-95230.rs +++ b/src/test/ui/higher-rank-trait-bounds/issue-95230.rs diff --git a/src/test/ui/issues/issue-11374.stderr b/src/test/ui/issues/issue-11374.stderr index 3a1d43310e2..15b2bbeb7c2 100644 --- a/src/test/ui/issues/issue-11374.stderr +++ b/src/test/ui/issues/issue-11374.stderr @@ -14,7 +14,7 @@ note: associated function defined here --> $DIR/issue-11374.rs:13:12 | LL | pub fn read_to(&mut self, vec: &mut [u8]) { - | ^^^^^^^ --------- -------------- + | ^^^^^^^ -------------- error: aborting due to previous error diff --git a/src/test/ui/issues/issue-18819.stderr b/src/test/ui/issues/issue-18819.stderr index 6499dd0d81b..e499d0572f6 100644 --- a/src/test/ui/issues/issue-18819.stderr +++ b/src/test/ui/issues/issue-18819.stderr @@ -2,11 +2,13 @@ error[E0061]: this function takes 2 arguments but 1 argument was supplied --> $DIR/issue-18819.rs:16:5 | LL | print_x(X); - | ^^^^^^^--- - | || - | |expected reference, found struct `X` - | an argument of type `&str` is missing + | ^^^^^^^--- an argument of type `&str` is missing | +note: expected reference, found struct `X` + --> $DIR/issue-18819.rs:16:13 + | +LL | print_x(X); + | ^ = note: expected reference `&dyn Foo<Item = bool>` found struct `X` note: function defined here diff --git a/src/test/ui/issues/issue-21950.stderr b/src/test/ui/issues/issue-21950.stderr index 4909398bb84..731615a6bd8 100644 --- a/src/test/ui/issues/issue-21950.stderr +++ b/src/test/ui/issues/issue-21950.stderr @@ -1,3 +1,12 @@ +error[E0191]: the value of the associated type `Output` (from trait `Add`) must be specified + --> $DIR/issue-21950.rs:10:25 + | +LL | type Output; + | ----------- `Output` defined here +... +LL | let x = &10 as &dyn Add; + | ^^^ help: specify the associated type: `Add<Output = Type>` + error[E0393]: the type parameter `Rhs` must be explicitly specified --> $DIR/issue-21950.rs:10:25 | @@ -9,15 +18,6 @@ LL | let x = &10 as &dyn Add; | = note: because of the default `Self` reference, type parameters must be specified on object types -error[E0191]: the value of the associated type `Output` (from trait `Add`) must be specified - --> $DIR/issue-21950.rs:10:25 - | -LL | type Output; - | ----------- `Output` defined here -... -LL | let x = &10 as &dyn Add; - | ^^^ help: specify the associated type: `Add<Output = Type>` - error: aborting due to 2 previous errors Some errors have detailed explanations: E0191, E0393. diff --git a/src/test/ui/let-else/issue-94176.rs b/src/test/ui/let-else/issue-94176.rs new file mode 100644 index 00000000000..e35bbd88830 --- /dev/null +++ b/src/test/ui/let-else/issue-94176.rs @@ -0,0 +1,10 @@ +// Issue #94176: wrong span for the error message of a mismatched type error, +// if the function uses a `let else` construct. +#![feature(let_else)] + +pub fn test(a: Option<u32>) -> Option<u32> { //~ ERROR mismatched types + let Some(_) = a else { return None; }; + println!("Foo"); +} + +fn main() {} diff --git a/src/test/ui/let-else/issue-94176.stderr b/src/test/ui/let-else/issue-94176.stderr new file mode 100644 index 00000000000..0cb97aceebf --- /dev/null +++ b/src/test/ui/let-else/issue-94176.stderr @@ -0,0 +1,19 @@ +error[E0308]: mismatched types + --> $DIR/issue-94176.rs:5:32 + | +LL | pub fn test(a: Option<u32>) -> Option<u32> { + | ---- ^^^^^^^^^^^ expected enum `Option`, found `()` + | | + | implicitly returns `()` as its body has no tail or `return` expression + | + = note: expected enum `Option<u32>` + found unit type `()` +help: consider returning the local binding `a` + | +LL ~ println!("Foo"); +LL + a + | + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/let-else/let-else-then-diverge.rs b/src/test/ui/let-else/let-else-then-diverge.rs new file mode 100644 index 00000000000..49633d943be --- /dev/null +++ b/src/test/ui/let-else/let-else-then-diverge.rs @@ -0,0 +1,19 @@ +// +// popped up in in #94012, where an alternative desugaring was +// causing unreachable code errors + +#![feature(let_else)] +#![deny(unused_variables)] +#![deny(unreachable_code)] + +fn let_else_diverge() -> bool { + let Some(_) = Some("test") else { + let x = 5; //~ ERROR unused variable: `x` + return false; + }; + return true; +} + +fn main() { + let_else_diverge(); +} diff --git a/src/test/ui/let-else/let-else-then-diverge.stderr b/src/test/ui/let-else/let-else-then-diverge.stderr new file mode 100644 index 00000000000..ceb61029d38 --- /dev/null +++ b/src/test/ui/let-else/let-else-then-diverge.stderr @@ -0,0 +1,14 @@ +error: unused variable: `x` + --> $DIR/let-else-then-diverge.rs:11:13 + | +LL | let x = 5; + | ^ help: if this is intentional, prefix it with an underscore: `_x` + | +note: the lint level is defined here + --> $DIR/let-else-then-diverge.rs:6:9 + | +LL | #![deny(unused_variables)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/methods/method-call-err-msg.stderr b/src/test/ui/methods/method-call-err-msg.stderr index 690fe8fa7af..e9b49c89bf1 100644 --- a/src/test/ui/methods/method-call-err-msg.stderr +++ b/src/test/ui/methods/method-call-err-msg.stderr @@ -8,7 +8,7 @@ note: associated function defined here --> $DIR/method-call-err-msg.rs:5:8 | LL | fn zero(self) -> Foo { self } - | ^^^^ ---- + | ^^^^ help: remove the extra argument | LL | x.zero() @@ -24,7 +24,7 @@ note: associated function defined here --> $DIR/method-call-err-msg.rs:6:8 | LL | fn one(self, _: isize) -> Foo { self } - | ^^^ ---- -------- + | ^^^ -------- help: provide the argument | LL | .one(/* isize */) @@ -40,7 +40,7 @@ note: associated function defined here --> $DIR/method-call-err-msg.rs:7:8 | LL | fn two(self, _: isize, _: isize) -> Foo { self } - | ^^^ ---- -------- -------- + | ^^^ -------- -------- help: provide the argument | LL | .two(0, /* isize */); @@ -80,7 +80,7 @@ note: associated function defined here --> $DIR/method-call-err-msg.rs:8:8 | LL | fn three<T>(self, _: T, _: T, _: T) -> Foo { self } - | ^^^^^ ---- ---- ---- ---- + | ^^^^^ ---- ---- ---- help: provide the arguments | LL | y.three::<usize>(/* usize */, /* usize */, /* usize */); diff --git a/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.fixed b/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.fixed new file mode 100644 index 00000000000..64ab6f62b77 --- /dev/null +++ b/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.fixed @@ -0,0 +1,8 @@ +// run-rustfix + +fn main() { + const _FOO: i32 = 123; + //~^ ERROR const` and `let` are mutually exclusive + const _BAR: i32 = 123; + //~^ ERROR `const` and `let` are mutually exclusive +} diff --git a/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.rs b/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.rs new file mode 100644 index 00000000000..50520971ffb --- /dev/null +++ b/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.rs @@ -0,0 +1,8 @@ +// run-rustfix + +fn main() { + const let _FOO: i32 = 123; + //~^ ERROR const` and `let` are mutually exclusive + let const _BAR: i32 = 123; + //~^ ERROR `const` and `let` are mutually exclusive +} diff --git a/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.stderr b/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.stderr new file mode 100644 index 00000000000..72377fc379c --- /dev/null +++ b/src/test/ui/parser/issue-99910-const-let-mutually-exclusive.stderr @@ -0,0 +1,14 @@ +error: `const` and `let` are mutually exclusive + --> $DIR/issue-99910-const-let-mutually-exclusive.rs:4:5 + | +LL | const let _FOO: i32 = 123; + | ^^^^^^^^^ help: remove `let`: `const` + +error: `const` and `let` are mutually exclusive + --> $DIR/issue-99910-const-let-mutually-exclusive.rs:6:5 + | +LL | let const _BAR: i32 = 123; + | ^^^^^^^^^ help: remove `let`: `const` + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/parser/struct-filed-with-attr.fixed b/src/test/ui/parser/struct-filed-with-attr.fixed new file mode 100644 index 00000000000..a799ec8ca2e --- /dev/null +++ b/src/test/ui/parser/struct-filed-with-attr.fixed @@ -0,0 +1,18 @@ +// Issue: 100461, Try to give a helpful diagnostic even when the next struct field has an attribute. +// run-rustfix + +struct Feelings { + owo: bool, + //~^ ERROR expected `,`, or `}`, found `#` + #[allow(unused)] + uwu: bool, +} + +impl Feelings { + #[allow(unused)] + fn hmm(&self) -> bool { + self.owo + } +} + +fn main() { } diff --git a/src/test/ui/parser/struct-filed-with-attr.rs b/src/test/ui/parser/struct-filed-with-attr.rs new file mode 100644 index 00000000000..bfc78e15b5b --- /dev/null +++ b/src/test/ui/parser/struct-filed-with-attr.rs @@ -0,0 +1,18 @@ +// Issue: 100461, Try to give a helpful diagnostic even when the next struct field has an attribute. +// run-rustfix + +struct Feelings { + owo: bool + //~^ ERROR expected `,`, or `}`, found `#` + #[allow(unused)] + uwu: bool, +} + +impl Feelings { + #[allow(unused)] + fn hmm(&self) -> bool { + self.owo + } +} + +fn main() { } diff --git a/src/test/ui/parser/struct-filed-with-attr.stderr b/src/test/ui/parser/struct-filed-with-attr.stderr new file mode 100644 index 00000000000..c2cd7e82ead --- /dev/null +++ b/src/test/ui/parser/struct-filed-with-attr.stderr @@ -0,0 +1,8 @@ +error: expected `,`, or `}`, found `#` + --> $DIR/struct-filed-with-attr.rs:5:14 + | +LL | owo: bool + | ^ help: try adding a comma: `,` + +error: aborting due to previous error + diff --git a/src/test/ui/parser/suggest-const-for-global-var.rs b/src/test/ui/parser/suggest-const-for-global-var.rs new file mode 100644 index 00000000000..d6216cb7ac2 --- /dev/null +++ b/src/test/ui/parser/suggest-const-for-global-var.rs @@ -0,0 +1,6 @@ +let X: i32 = 12; +//~^ ERROR expected item, found keyword `let` + +fn main() { + println!("{}", X); +} diff --git a/src/test/ui/parser/suggest-const-for-global-var.stderr b/src/test/ui/parser/suggest-const-for-global-var.stderr new file mode 100644 index 00000000000..94e44ec7f6c --- /dev/null +++ b/src/test/ui/parser/suggest-const-for-global-var.stderr @@ -0,0 +1,8 @@ +error: expected item, found keyword `let` + --> $DIR/suggest-const-for-global-var.rs:1:1 + | +LL | let X: i32 = 12; + | ^^^ consider using `const` or `static` instead of `let` for global variables + +error: aborting due to previous error + diff --git a/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.fixed b/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.fixed new file mode 100644 index 00000000000..63704735490 --- /dev/null +++ b/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.fixed @@ -0,0 +1,7 @@ +// run-rustfix + +trait Foo { + fn bar() {} //~ ERROR non-item in item list +} + +fn main() {} diff --git a/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.rs b/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.rs new file mode 100644 index 00000000000..4650b05e20c --- /dev/null +++ b/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.rs @@ -0,0 +1,7 @@ +// run-rustfix + +trait Foo { + fn bar() {}; //~ ERROR non-item in item list +} + +fn main() {} diff --git a/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.stderr b/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.stderr new file mode 100644 index 00000000000..396e0c130f1 --- /dev/null +++ b/src/test/ui/parser/suggest-removing-semicolon-after-impl-trait-items.stderr @@ -0,0 +1,15 @@ +error: non-item in item list + --> $DIR/suggest-removing-semicolon-after-impl-trait-items.rs:4:16 + | +LL | trait Foo { + | - item list starts here +LL | fn bar() {}; + | ^ + | | + | non-item starts here + | help: consider removing this semicolon +LL | } + | - item list ends here + +error: aborting due to previous error + diff --git a/src/test/ui/resolve/issue-100365.rs b/src/test/ui/resolve/issue-100365.rs new file mode 100644 index 00000000000..1d883503606 --- /dev/null +++ b/src/test/ui/resolve/issue-100365.rs @@ -0,0 +1,50 @@ +fn main() { + let addr = Into::<std::net::IpAddr>.into([127, 0, 0, 1]); + //~^ ERROR expected value, found trait `Into` + //~| HELP use the path separator + + let _ = Into.into(()); + //~^ ERROR expected value, found trait `Into` + //~| HELP use the path separator + + let _ = Into::<()>.into; + //~^ ERROR expected value, found trait `Into` + //~| HELP use the path separator +} + +macro_rules! Trait { + () => { + ::std::iter::Iterator + //~^ ERROR expected value, found trait `std::iter::Iterator` + //~| ERROR expected value, found trait `std::iter::Iterator` + }; +} + +macro_rules! create { + () => { + Into::<String>.into("") + //~^ ERROR expected value, found trait `Into` + //~| HELP use the path separator + }; +} + +fn interaction_with_macros() { + // + // Note that if the receiver is a macro call, we do not want to suggest to replace + // `.` with `::` as that would be a syntax error. + // Since the receiver is a trait and not a type, we cannot suggest to surround + // it with angle brackets. It would be interpreted as a trait object type void of + // `dyn` which is most likely not what the user intended to write. + // `<_ as Trait!()>::` is also not an option as it's equally syntactically invalid. + // + + Trait!().map(std::convert::identity); // no `help` here! + + Trait!().map; // no `help` here! + + // + // Ensure that the suggestion is shown for expressions inside of macro definitions. + // + + let _ = create!(); +} diff --git a/src/test/ui/resolve/issue-100365.stderr b/src/test/ui/resolve/issue-100365.stderr new file mode 100644 index 00000000000..372d7726668 --- /dev/null +++ b/src/test/ui/resolve/issue-100365.stderr @@ -0,0 +1,54 @@ +error[E0423]: expected value, found trait `Into` + --> $DIR/issue-100365.rs:2:16 + | +LL | let addr = Into::<std::net::IpAddr>.into([127, 0, 0, 1]); + | ^^^^^^^^^^^^^^^^^^^^^^^^- help: use the path separator to refer to an item: `::` + +error[E0423]: expected value, found trait `Into` + --> $DIR/issue-100365.rs:6:13 + | +LL | let _ = Into.into(()); + | ^^^^- help: use the path separator to refer to an item: `::` + +error[E0423]: expected value, found trait `Into` + --> $DIR/issue-100365.rs:10:13 + | +LL | let _ = Into::<()>.into; + | ^^^^^^^^^^- help: use the path separator to refer to an item: `::` + +error[E0423]: expected value, found trait `std::iter::Iterator` + --> $DIR/issue-100365.rs:17:9 + | +LL | ::std::iter::Iterator + | ^^^^^^^^^^^^^^^^^^^^^ not a value +... +LL | Trait!().map(std::convert::identity); // no `help` here! + | -------- in this macro invocation + | + = note: this error originates in the macro `Trait` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0423]: expected value, found trait `std::iter::Iterator` + --> $DIR/issue-100365.rs:17:9 + | +LL | ::std::iter::Iterator + | ^^^^^^^^^^^^^^^^^^^^^ not a value +... +LL | Trait!().map; // no `help` here! + | -------- in this macro invocation + | + = note: this error originates in the macro `Trait` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0423]: expected value, found trait `Into` + --> $DIR/issue-100365.rs:25:9 + | +LL | Into::<String>.into("") + | ^^^^^^^^^^^^^^- help: use the path separator to refer to an item: `::` +... +LL | let _ = create!(); + | --------- in this macro invocation + | + = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 6 previous errors + +For more information about this error, try `rustc --explain E0423`. diff --git a/src/test/ui/resolve/issue-22692.rs b/src/test/ui/resolve/issue-22692.rs index 1d8f442221d..31a76261408 100644 --- a/src/test/ui/resolve/issue-22692.rs +++ b/src/test/ui/resolve/issue-22692.rs @@ -1,3 +1,60 @@ fn main() { - let _ = String.new(); //~ ERROR expected value, found struct `String` + let _ = String.new(); + //~^ ERROR expected value, found struct `String` + //~| HELP use the path separator + + let _ = String.default; + //~^ ERROR expected value, found struct `String` + //~| HELP use the path separator + + let _ = Vec::<()>.with_capacity(1); + //~^ ERROR expected value, found struct `Vec` + //~| HELP use the path separator +} + +macro_rules! Type { + () => { + ::std::cell::Cell + //~^ ERROR expected value, found struct `std::cell::Cell` + //~| ERROR expected value, found struct `std::cell::Cell` + //~| ERROR expected value, found struct `std::cell::Cell` + }; +} + +macro_rules! create { + (type method) => { + Vec.new() + //~^ ERROR expected value, found struct `Vec` + //~| HELP use the path separator + }; + (type field) => { + Vec.new + //~^ ERROR expected value, found struct `Vec` + //~| HELP use the path separator + }; + (macro method) => { + Type!().new(0) + //~^ HELP use the path separator + }; +} + +fn interaction_with_macros() { + // + // Verify that we do not only suggest to replace `.` with `::` if the receiver is a + // macro call but that we also correctly suggest to surround it with angle brackets. + // + + Type!().get(); + //~^ HELP use the path separator + + Type! {}.get; + //~^ HELP use the path separator + + // + // Ensure that the suggestion is shown for expressions inside of macro definitions. + // + + let _ = create!(type method); + let _ = create!(type field); + let _ = create!(macro method); } diff --git a/src/test/ui/resolve/issue-22692.stderr b/src/test/ui/resolve/issue-22692.stderr index e076419f68d..6962aa161e9 100644 --- a/src/test/ui/resolve/issue-22692.stderr +++ b/src/test/ui/resolve/issue-22692.stderr @@ -2,10 +2,87 @@ error[E0423]: expected value, found struct `String` --> $DIR/issue-22692.rs:2:13 | LL | let _ = String.new(); - | ^^^^^^---- - | | - | help: use the path separator to refer to an item: `String::new` + | ^^^^^^- help: use the path separator to refer to an item: `::` -error: aborting due to previous error +error[E0423]: expected value, found struct `String` + --> $DIR/issue-22692.rs:6:13 + | +LL | let _ = String.default; + | ^^^^^^- help: use the path separator to refer to an item: `::` + +error[E0423]: expected value, found struct `Vec` + --> $DIR/issue-22692.rs:10:13 + | +LL | let _ = Vec::<()>.with_capacity(1); + | ^^^^^^^^^- help: use the path separator to refer to an item: `::` + +error[E0423]: expected value, found struct `std::cell::Cell` + --> $DIR/issue-22692.rs:17:9 + | +LL | ::std::cell::Cell + | ^^^^^^^^^^^^^^^^^ +... +LL | Type!().get(); + | ------- in this macro invocation + | + = note: this error originates in the macro `Type` (in Nightly builds, run with -Z macro-backtrace for more info) +help: use the path separator to refer to an item + | +LL | <Type!()>::get(); + | ~~~~~~~~~~~ + +error[E0423]: expected value, found struct `std::cell::Cell` + --> $DIR/issue-22692.rs:17:9 + | +LL | ::std::cell::Cell + | ^^^^^^^^^^^^^^^^^ +... +LL | Type! {}.get; + | -------- in this macro invocation + | + = note: this error originates in the macro `Type` (in Nightly builds, run with -Z macro-backtrace for more info) +help: use the path separator to refer to an item + | +LL | <Type! {}>::get; + | ~~~~~~~~~~~~ + +error[E0423]: expected value, found struct `Vec` + --> $DIR/issue-22692.rs:26:9 + | +LL | Vec.new() + | ^^^- help: use the path separator to refer to an item: `::` +... +LL | let _ = create!(type method); + | -------------------- in this macro invocation + | + = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0423]: expected value, found struct `Vec` + --> $DIR/issue-22692.rs:31:9 + | +LL | Vec.new + | ^^^- help: use the path separator to refer to an item: `::` +... +LL | let _ = create!(type field); + | ------------------- in this macro invocation + | + = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0423]: expected value, found struct `std::cell::Cell` + --> $DIR/issue-22692.rs:17:9 + | +LL | ::std::cell::Cell + | ^^^^^^^^^^^^^^^^^ +... +LL | let _ = create!(macro method); + | --------------------- in this macro invocation + | + = note: this error originates in the macro `Type` which comes from the expansion of the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info) +help: use the path separator to refer to an item + | +LL | <Type!()>::new(0) + | ~~~~~~~~~~~ + +error: aborting due to 8 previous errors For more information about this error, try `rustc --explain E0423`. diff --git a/src/test/ui/resolve/suggest-path-for-tuple-struct.stderr b/src/test/ui/resolve/suggest-path-for-tuple-struct.stderr index 957045ca74b..4764cf2db20 100644 --- a/src/test/ui/resolve/suggest-path-for-tuple-struct.stderr +++ b/src/test/ui/resolve/suggest-path-for-tuple-struct.stderr @@ -2,17 +2,13 @@ error[E0423]: expected value, found struct `SomeTupleStruct` --> $DIR/suggest-path-for-tuple-struct.rs:22:13 | LL | let _ = SomeTupleStruct.new(); - | ^^^^^^^^^^^^^^^---- - | | - | help: use the path separator to refer to an item: `SomeTupleStruct::new` + | ^^^^^^^^^^^^^^^- help: use the path separator to refer to an item: `::` error[E0423]: expected value, found struct `SomeRegularStruct` --> $DIR/suggest-path-for-tuple-struct.rs:24:13 | LL | let _ = SomeRegularStruct.new(); - | ^^^^^^^^^^^^^^^^^---- - | | - | help: use the path separator to refer to an item: `SomeRegularStruct::new` + | ^^^^^^^^^^^^^^^^^- help: use the path separator to refer to an item: `::` error: aborting due to 2 previous errors diff --git a/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.rs b/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.rs index 204a272402d..d5d6b13d62c 100644 --- a/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.rs +++ b/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.rs @@ -16,44 +16,96 @@ pub mod a { fn h1() -> i32 { a.I //~^ ERROR expected value, found module `a` + //~| HELP use the path separator } fn h2() -> i32 { a.g() //~^ ERROR expected value, found module `a` + //~| HELP use the path separator } fn h3() -> i32 { a.b.J //~^ ERROR expected value, found module `a` + //~| HELP use the path separator } fn h4() -> i32 { a::b.J //~^ ERROR expected value, found module `a::b` + //~| HELP a constant with a similar name exists + //~| HELP use the path separator } fn h5() { a.b.f(); //~^ ERROR expected value, found module `a` + //~| HELP use the path separator let v = Vec::new(); v.push(a::b); //~^ ERROR expected value, found module `a::b` + //~| HELP a constant with a similar name exists } fn h6() -> i32 { a::b.f() //~^ ERROR expected value, found module `a::b` + //~| HELP a constant with a similar name exists + //~| HELP use the path separator } fn h7() { a::b //~^ ERROR expected value, found module `a::b` + //~| HELP a constant with a similar name exists } fn h8() -> i32 { a::b() //~^ ERROR expected function, found module `a::b` + //~| HELP a constant with a similar name exists +} + +macro_rules! module { + () => { + a + //~^ ERROR expected value, found module `a` + //~| ERROR expected value, found module `a` + }; +} + +macro_rules! create { + (method) => { + a.f() + //~^ ERROR expected value, found module `a` + //~| HELP use the path separator + }; + (field) => { + a.f + //~^ ERROR expected value, found module `a` + //~| HELP use the path separator + }; +} + +fn h9() { + // + // Note that if the receiver is a macro call, we do not want to suggest to replace + // `.` with `::` as that would be a syntax error. + // Since the receiver is a module and not a type, we cannot suggest to surround + // it with angle brackets. + // + + module!().g::<()>(); // no `help` here! + + module!().g; // no `help` here! + + // + // Ensure that the suggestion is shown for expressions inside of macro definitions. + // + + let _ = create!(method); + let _ = create!(field); } fn main() {} diff --git a/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr b/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr index 54b242123eb..a4ce0deeb70 100644 --- a/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr +++ b/src/test/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr @@ -2,28 +2,22 @@ error[E0423]: expected value, found module `a` --> $DIR/suggest-path-instead-of-mod-dot-item.rs:17:5 | LL | a.I - | ^-- - | | - | help: use the path separator to refer to an item: `a::I` + | ^- help: use the path separator to refer to an item: `::` error[E0423]: expected value, found module `a` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:22:5 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:23:5 | LL | a.g() - | ^-- - | | - | help: use the path separator to refer to an item: `a::g` + | ^- help: use the path separator to refer to an item: `::` error[E0423]: expected value, found module `a` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:27:5 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:29:5 | LL | a.b.J - | ^-- - | | - | help: use the path separator to refer to an item: `a::b` + | ^- help: use the path separator to refer to an item: `::` error[E0423]: expected value, found module `a::b` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:32:5 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:35:5 | LL | pub const I: i32 = 1; | --------------------- similarly named constant `I` defined here @@ -34,22 +28,20 @@ LL | a::b.J help: use the path separator to refer to an item | LL | a::b::J - | + | ~~ help: a constant with a similar name exists | LL | a::I.J | ~ error[E0423]: expected value, found module `a` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:37:5 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:42:5 | LL | a.b.f(); - | ^-- - | | - | help: use the path separator to refer to an item: `a::b` + | ^- help: use the path separator to refer to an item: `::` error[E0423]: expected value, found module `a::b` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:40:12 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:46:12 | LL | pub const I: i32 = 1; | --------------------- similarly named constant `I` defined here @@ -60,7 +52,7 @@ LL | v.push(a::b); | help: a constant with a similar name exists: `I` error[E0423]: expected value, found module `a::b` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:45:5 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:52:5 | LL | pub const I: i32 = 1; | --------------------- similarly named constant `I` defined here @@ -71,14 +63,14 @@ LL | a::b.f() help: use the path separator to refer to an item | LL | a::b::f() - | ~~~~~~~ + | ~~ help: a constant with a similar name exists | LL | a::I.f() | ~ error[E0423]: expected value, found module `a::b` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:50:5 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:59:5 | LL | pub const I: i32 = 1; | --------------------- similarly named constant `I` defined here @@ -89,7 +81,7 @@ LL | a::b | help: a constant with a similar name exists: `I` error[E0423]: expected function, found module `a::b` - --> $DIR/suggest-path-instead-of-mod-dot-item.rs:55:5 + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:65:5 | LL | pub const I: i32 = 1; | --------------------- similarly named constant `I` defined here @@ -99,6 +91,50 @@ LL | a::b() | | | help: a constant with a similar name exists: `I` -error: aborting due to 9 previous errors +error[E0423]: expected value, found module `a` + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:72:9 + | +LL | a + | ^ not a value +... +LL | module!().g::<()>(); // no `help` here! + | --------- in this macro invocation + | + = note: this error originates in the macro `module` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0423]: expected value, found module `a` + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:72:9 + | +LL | a + | ^ not a value +... +LL | module!().g; // no `help` here! + | --------- in this macro invocation + | + = note: this error originates in the macro `module` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0423]: expected value, found module `a` + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:80:9 + | +LL | a.f() + | ^- help: use the path separator to refer to an item: `::` +... +LL | let _ = create!(method); + | --------------- in this macro invocation + | + = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0423]: expected value, found module `a` + --> $DIR/suggest-path-instead-of-mod-dot-item.rs:85:9 + | +LL | a.f + | ^- help: use the path separator to refer to an item: `::` +... +LL | let _ = create!(field); + | -------------- in this macro invocation + | + = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 13 previous errors For more information about this error, try `rustc --explain E0423`. diff --git a/src/test/ui/sanitize/memory.rs b/src/test/ui/sanitize/memory.rs index b53f19a5b01..83f79679c6e 100644 --- a/src/test/ui/sanitize/memory.rs +++ b/src/test/ui/sanitize/memory.rs @@ -6,7 +6,7 @@ // run-fail // error-pattern: MemorySanitizer: use-of-uninitialized-value // error-pattern: Uninitialized value was created by an allocation -// error-pattern: in the stack frame of function 'main' +// error-pattern: in the stack frame // // This test case intentionally limits the usage of the std, // since it will be linked with an uninstrumented version of it. diff --git a/src/test/ui/span/issue-34264.stderr b/src/test/ui/span/issue-34264.stderr index e676d7372e8..28a911d0c5b 100644 --- a/src/test/ui/span/issue-34264.stderr +++ b/src/test/ui/span/issue-34264.stderr @@ -78,7 +78,7 @@ note: function defined here --> $DIR/issue-34264.rs:3:4 | LL | fn bar(x, y: usize) {} - | ^^^ - -------- + | ^^^ -------- error[E0061]: this function takes 2 arguments but 3 arguments were supplied --> $DIR/issue-34264.rs:10:5 diff --git a/src/test/ui/span/missing-unit-argument.stderr b/src/test/ui/span/missing-unit-argument.stderr index e68260e4a09..d2afd277ecf 100644 --- a/src/test/ui/span/missing-unit-argument.stderr +++ b/src/test/ui/span/missing-unit-argument.stderr @@ -72,7 +72,7 @@ note: associated function defined here --> $DIR/missing-unit-argument.rs:6:8 | LL | fn baz(self, (): ()) { } - | ^^^ ---- ------ + | ^^^ ------ help: provide the argument | LL | S.baz(()); @@ -88,7 +88,7 @@ note: associated function defined here --> $DIR/missing-unit-argument.rs:7:8 | LL | fn generic<T>(self, _: T) { } - | ^^^^^^^ ---- ---- + | ^^^^^^^ ---- help: provide the argument | LL | S.generic::<()>(()); diff --git a/src/test/ui/stability-attribute/auxiliary/ctor-stability.rs b/src/test/ui/stability-attribute/auxiliary/ctor-stability.rs new file mode 100644 index 00000000000..74c6023d7fb --- /dev/null +++ b/src/test/ui/stability-attribute/auxiliary/ctor-stability.rs @@ -0,0 +1,8 @@ +#![crate_type = "lib"] +#![feature(staged_api)] +#![stable(feature = "none", since = "1.0")] + +#[stable(feature = "none", since = "1.0")] +pub enum Foo { + A, +} diff --git a/src/test/ui/stability-attribute/ctor-stability.rs b/src/test/ui/stability-attribute/ctor-stability.rs new file mode 100644 index 00000000000..fcab0cb1099 --- /dev/null +++ b/src/test/ui/stability-attribute/ctor-stability.rs @@ -0,0 +1,8 @@ +// aux-build:ctor-stability.rs +// check-pass + +extern crate ctor_stability; + +fn main() { + let _ = ctor_stability::Foo::A; +} diff --git a/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr b/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr index 805c75f464c..4c952669cfa 100644 --- a/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr +++ b/src/test/ui/suggestions/args-instead-of-tuple-errors.stderr @@ -2,10 +2,13 @@ error[E0061]: this enum variant takes 1 argument but 2 arguments were supplied --> $DIR/args-instead-of-tuple-errors.rs:6:34 | LL | let _: Option<(i32, bool)> = Some(1, 2); - | ^^^^ - - argument of type `{integer}` unexpected - | | - | expected tuple, found integer + | ^^^^ - argument of type `{integer}` unexpected | +note: expected tuple, found integer + --> $DIR/args-instead-of-tuple-errors.rs:6:39 + | +LL | let _: Option<(i32, bool)> = Some(1, 2); + | ^ = note: expected tuple `(i32, bool)` found type `{integer}` note: tuple variant defined here @@ -22,10 +25,13 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $DIR/args-instead-of-tuple-errors.rs:8:5 | LL | int_bool(1, 2); - | ^^^^^^^^ - - argument of type `{integer}` unexpected - | | - | expected tuple, found integer + | ^^^^^^^^ - argument of type `{integer}` unexpected | +note: expected tuple, found integer + --> $DIR/args-instead-of-tuple-errors.rs:8:14 + | +LL | int_bool(1, 2); + | ^ = note: expected tuple `(i32, bool)` found type `{integer}` note: function defined here diff --git a/src/test/ui/suggestions/assoc-const-as-field.stderr b/src/test/ui/suggestions/assoc-const-as-field.stderr index 5e746ecb2f2..78e5634b2de 100644 --- a/src/test/ui/suggestions/assoc-const-as-field.stderr +++ b/src/test/ui/suggestions/assoc-const-as-field.stderr @@ -2,9 +2,7 @@ error[E0423]: expected value, found struct `Mod::Foo` --> $DIR/assoc-const-as-field.rs:11:9 | LL | foo(Mod::Foo.Bar); - | ^^^^^^^^---- - | | - | help: use the path separator to refer to an item: `Mod::Foo::Bar` + | ^^^^^^^^- help: use the path separator to refer to an item: `::` error: aborting due to previous error diff --git a/src/test/ui/traits/alias/generic-default-in-dyn.rs b/src/test/ui/traits/alias/generic-default-in-dyn.rs new file mode 100644 index 00000000000..d44e1c2a975 --- /dev/null +++ b/src/test/ui/traits/alias/generic-default-in-dyn.rs @@ -0,0 +1,10 @@ +trait SendEqAlias<T> = PartialEq; +//~^ ERROR trait aliases are experimental + +struct Foo<T>(dyn SendEqAlias<T>); +//~^ ERROR the type parameter `Rhs` must be explicitly specified [E0393] + +struct Bar<T>(dyn SendEqAlias<T>, T); +//~^ ERROR the type parameter `Rhs` must be explicitly specified [E0393] + +fn main() {} diff --git a/src/test/ui/traits/alias/generic-default-in-dyn.stderr b/src/test/ui/traits/alias/generic-default-in-dyn.stderr new file mode 100644 index 00000000000..76a068e864a --- /dev/null +++ b/src/test/ui/traits/alias/generic-default-in-dyn.stderr @@ -0,0 +1,39 @@ +error[E0658]: trait aliases are experimental + --> $DIR/generic-default-in-dyn.rs:1:1 + | +LL | trait SendEqAlias<T> = PartialEq; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: see issue #41517 <https://github.com/rust-lang/rust/issues/41517> for more information + = help: add `#![feature(trait_alias)]` to the crate attributes to enable + +error[E0393]: the type parameter `Rhs` must be explicitly specified + --> $DIR/generic-default-in-dyn.rs:4:19 + | +LL | struct Foo<T>(dyn SendEqAlias<T>); + | ^^^^^^^^^^^^^^ missing reference to `Rhs` + | + ::: $SRC_DIR/core/src/cmp.rs:LL:COL + | +LL | pub trait PartialEq<Rhs: ?Sized = Self> { + | --------------------------------------- type parameter `Rhs` must be specified for this + | + = note: because of the default `Self` reference, type parameters must be specified on object types + +error[E0393]: the type parameter `Rhs` must be explicitly specified + --> $DIR/generic-default-in-dyn.rs:7:19 + | +LL | struct Bar<T>(dyn SendEqAlias<T>, T); + | ^^^^^^^^^^^^^^ missing reference to `Rhs` + | + ::: $SRC_DIR/core/src/cmp.rs:LL:COL + | +LL | pub trait PartialEq<Rhs: ?Sized = Self> { + | --------------------------------------- type parameter `Rhs` must be specified for this + | + = note: because of the default `Self` reference, type parameters must be specified on object types + +error: aborting due to 3 previous errors + +Some errors have detailed explanations: E0393, E0658. +For more information about an error, try `rustc --explain E0393`. diff --git a/src/test/ui/traits/alias/self-in-generics.rs b/src/test/ui/traits/alias/self-in-generics.rs new file mode 100644 index 00000000000..6b99431f5bb --- /dev/null +++ b/src/test/ui/traits/alias/self-in-generics.rs @@ -0,0 +1,8 @@ +#![feature(trait_alias)] + +pub trait SelfInput = Fn(&mut Self); + +pub fn f(_f: &dyn SelfInput) {} +//~^ ERROR the trait alias `SelfInput` cannot be made into an object [E0038] + +fn main() {} diff --git a/src/test/ui/traits/alias/self-in-generics.stderr b/src/test/ui/traits/alias/self-in-generics.stderr new file mode 100644 index 00000000000..a1056872ea6 --- /dev/null +++ b/src/test/ui/traits/alias/self-in-generics.stderr @@ -0,0 +1,11 @@ +error[E0038]: the trait alias `SelfInput` cannot be made into an object + --> $DIR/self-in-generics.rs:5:19 + | +LL | pub fn f(_f: &dyn SelfInput) {} + | ^^^^^^^^^ + | + = note: it cannot use `Self` as a type parameter in a supertrait or `where`-clause + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0038`. diff --git a/src/test/ui/traits/multidispatch-bad.stderr b/src/test/ui/traits/multidispatch-bad.stderr index 8b6e610067b..d58f1e2d9e5 100644 --- a/src/test/ui/traits/multidispatch-bad.stderr +++ b/src/test/ui/traits/multidispatch-bad.stderr @@ -10,7 +10,7 @@ note: function defined here --> $DIR/multidispatch-bad.rs:13:4 | LL | fn test<T,U>(_: T, _: U) - | ^^^^ ---- ---- + | ^^^^ ---- help: change the type of the numeric literal from `i32` to `u32` | LL | test(22i32, 44u32); diff --git a/src/test/ui/unspecified-self-in-trait-ref.rs b/src/test/ui/traits/unspecified-self-in-trait-ref.rs index 158b5a98557..158b5a98557 100644 --- a/src/test/ui/unspecified-self-in-trait-ref.rs +++ b/src/test/ui/traits/unspecified-self-in-trait-ref.rs diff --git a/src/test/ui/unspecified-self-in-trait-ref.stderr b/src/test/ui/traits/unspecified-self-in-trait-ref.stderr index 7869176bb3a..7869176bb3a 100644 --- a/src/test/ui/unspecified-self-in-trait-ref.stderr +++ b/src/test/ui/traits/unspecified-self-in-trait-ref.stderr diff --git a/src/test/ui/tuple/add-tuple-within-arguments.stderr b/src/test/ui/tuple/add-tuple-within-arguments.stderr index 95df96ca0dd..7029d298d71 100644 --- a/src/test/ui/tuple/add-tuple-within-arguments.stderr +++ b/src/test/ui/tuple/add-tuple-within-arguments.stderr @@ -8,7 +8,7 @@ note: function defined here --> $DIR/add-tuple-within-arguments.rs:1:4 | LL | fn foo(s: &str, a: (i32, i32), s2: &str) {} - | ^^^ ------- ------------- -------- + | ^^^ ------------- help: wrap these arguments in parentheses to construct a tuple | LL | foo("hi", (1, 2), "hi"); @@ -28,7 +28,7 @@ note: function defined here --> $DIR/add-tuple-within-arguments.rs:3:4 | LL | fn bar(s: &str, a: (&str,), s2: &str) {} - | ^^^ ------- ---------- -------- + | ^^^ ---------- help: use a trailing comma to create a tuple with one element | LL | bar("hi", ("hi",), "hi"); diff --git a/src/test/ui/tuple/wrong_argument_ice-3.stderr b/src/test/ui/tuple/wrong_argument_ice-3.stderr index 2733fb3149b..968cb75db76 100644 --- a/src/test/ui/tuple/wrong_argument_ice-3.stderr +++ b/src/test/ui/tuple/wrong_argument_ice-3.stderr @@ -2,10 +2,13 @@ error[E0061]: this function takes 1 argument but 2 arguments were supplied --> $DIR/wrong_argument_ice-3.rs:9:16 | LL | groups.push(new_group, vec![process]); - | ^^^^ --------- ------------- argument of type `Vec<&Process>` unexpected - | | - | expected tuple, found struct `Vec` + | ^^^^ ------------- argument of type `Vec<&Process>` unexpected | +note: expected tuple, found struct `Vec` + --> $DIR/wrong_argument_ice-3.rs:9:21 + | +LL | groups.push(new_group, vec![process]); + | ^^^^^^^^^ = note: expected tuple `(Vec<String>, Vec<Process>)` found struct `Vec<String>` note: associated function defined here diff --git a/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr b/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr index 3241c9f8521..455f83f5721 100644 --- a/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr +++ b/src/test/ui/unboxed-closures/unboxed-closures-type-mismatch.stderr @@ -6,11 +6,11 @@ LL | let z = f(1_usize, 2); | | | arguments to this function are incorrect | -note: closure defined here - --> $DIR/unboxed-closures-type-mismatch.rs:4:17 +note: closure parameter defined here + --> $DIR/unboxed-closures-type-mismatch.rs:4:18 | LL | let mut f = |x: isize, y: isize| -> isize { x + y }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^ help: change the type of the numeric literal from `usize` to `isize` | LL | let z = f(1_isize, 2); diff --git a/src/test/ui/unpretty/pretty-let-else.rs b/src/test/ui/unpretty/pretty-let-else.rs new file mode 100644 index 00000000000..5abfa2523b7 --- /dev/null +++ b/src/test/ui/unpretty/pretty-let-else.rs @@ -0,0 +1,10 @@ +// compile-flags: -Zunpretty=hir +// check-pass + +#![feature(let_else)] + +fn foo(x: Option<u32>) { + let Some(_) = x else { panic!() }; +} + +fn main() {} diff --git a/src/test/ui/unpretty/pretty-let-else.stdout b/src/test/ui/unpretty/pretty-let-else.stdout new file mode 100644 index 00000000000..ffe1d1657aa --- /dev/null +++ b/src/test/ui/unpretty/pretty-let-else.stdout @@ -0,0 +1,18 @@ +// compile-flags: -Zunpretty=hir +// check-pass + +#![feature(let_else)] +#[prelude_import] +use ::std::prelude::rust_2015::*; +#[macro_use] +extern crate std; + +fn foo(x: + Option<u32>) { + let Some(_) = x else + { + + { ::std::rt::begin_panic("explicit panic") } + }; + } +fn main() { } diff --git a/src/tools/clippy/clippy_dev/src/lib.rs b/src/tools/clippy/clippy_dev/src/lib.rs index 8536e242992..8a6bd1cbdf5 100644 --- a/src/tools/clippy/clippy_dev/src/lib.rs +++ b/src/tools/clippy/clippy_dev/src/lib.rs @@ -1,4 +1,3 @@ -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(once_cell)] #![feature(rustc_private)] diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs index 2975399a8bb..e6a405f8170 100644 --- a/src/tools/clippy/clippy_lints/src/lib.rs +++ b/src/tools/clippy/clippy_lints/src/lib.rs @@ -4,7 +4,6 @@ #![feature(control_flow_enum)] #![feature(drain_filter)] #![feature(iter_intersperse)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(let_else)] #![feature(lint_reasons)] #![feature(never_type)] diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs index 2616a578bb8..dc772e5efee 100644 --- a/src/tools/clippy/clippy_utils/src/lib.rs +++ b/src/tools/clippy/clippy_utils/src/lib.rs @@ -2,7 +2,6 @@ #![feature(box_patterns)] #![feature(control_flow_enum)] #![feature(let_else)] -#![cfg_attr(bootstrap, feature(let_chains))] #![feature(lint_reasons)] #![feature(once_cell)] #![feature(rustc_private)] diff --git a/src/tools/clippy/src/driver.rs b/src/tools/clippy/src/driver.rs index c1ec2bd5bd6..235eae5af1e 100644 --- a/src/tools/clippy/src/driver.rs +++ b/src/tools/clippy/src/driver.rs @@ -95,7 +95,7 @@ struct ClippyCallbacks { impl rustc_driver::Callbacks for ClippyCallbacks { // JUSTIFICATION: necessary in clippy driver to set `mir_opt_level` - #[cfg_attr(not(bootstrap), allow(rustc::bad_opt_access))] + #[allow(rustc::bad_opt_access)] fn config(&mut self, config: &mut interface::Config) { let previous = config.register_lints.take(); let clippy_args_var = self.clippy_args_var.take(); diff --git a/src/tools/miri b/src/tools/miri -Subproject 39ee5747153bf13324870c4a912acbf1f9bfde3 +Subproject 50ef22af522f2545295090cc1ad3e4bd4aa8632 diff --git a/src/tools/tidy/src/bins.rs b/src/tools/tidy/src/bins.rs index 025b8ab9f0a..30903f56d93 100644 --- a/src/tools/tidy/src/bins.rs +++ b/src/tools/tidy/src/bins.rs @@ -98,7 +98,7 @@ mod os_impl { pub fn check(path: &Path, bad: &mut bool) { use std::ffi::OsStr; - const ALLOWED: &[&str] = &["configure"]; + const ALLOWED: &[&str] = &["configure", "x"]; crate::walk_no_read( path, diff --git a/x.sh b/x index 704d0f791f3..704d0f791f3 100755 --- a/x.sh +++ b/x diff --git a/x.ps1 b/x.ps1 index 1225443735f..86cea606591 100755 --- a/x.ps1 +++ b/x.ps1 @@ -1,6 +1,6 @@ #!/usr/bin/env pwsh -# See x.sh for why these scripts exist. +# See ./x for why these scripts exist. $xpy = Join-Path $PSScriptRoot x.py # Start-Process for some reason splits arguments on spaces. (Isn't powershell supposed to be simpler than bash?) diff --git a/x.py b/x.py index 6c68907c581..6df4033d55d 100755 --- a/x.py +++ b/x.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 # Some systems don't have `python3` in their PATH. This isn't supported by x.py directly; -# they should use `x.sh` or `x.ps1` instead. +# they should use `x` or `x.ps1` instead. # This file is only a "symlink" to bootstrap.py, all logic should go there. |