diff options
564 files changed, 17757 insertions, 15092 deletions
diff --git a/Cargo.lock b/Cargo.lock index fb401ed4cd0..fd23b2764c0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -576,7 +576,7 @@ dependencies = [ [[package]] name = "clippy" -version = "0.1.51" +version = "0.1.52" dependencies = [ "cargo_metadata 0.12.0", "clippy-mini-macro-test", @@ -597,7 +597,7 @@ version = "0.2.0" [[package]] name = "clippy_lints" -version = "0.1.51" +version = "0.1.52" dependencies = [ "cargo_metadata 0.12.0", "if_chain", @@ -726,9 +726,9 @@ dependencies = [ [[package]] name = "const_fn" -version = "0.4.2" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce90df4c658c62f12d78f7508cf92f9173e5184a539c10bfe54a3107b3ffd0f2" +checksum = "c478836e029dcef17fb47c89023448c64f781a046e0300e257ad8225ae59afab" [[package]] name = "constant_time_eq" @@ -3582,6 +3582,7 @@ dependencies = [ "rustc_errors", "rustc_expand", "rustc_feature", + "rustc_lexer", "rustc_parse", "rustc_parse_format", "rustc_session", @@ -3626,6 +3627,7 @@ version = "0.0.0" dependencies = [ "bitflags", "cc", + "itertools 0.9.0", "jobserver", "libc", "memmap", @@ -3912,6 +3914,7 @@ dependencies = [ "rustc_index", "rustc_middle", "rustc_parse_format", + "rustc_serialize", "rustc_session", "rustc_span", "rustc_target", diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index b7f227da73e..f076dca5cf5 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -1076,16 +1076,40 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_assoc_ty_constraint( &mut self, constraint: &AssocTyConstraint, - itctx: ImplTraitContext<'_, 'hir>, + mut itctx: ImplTraitContext<'_, 'hir>, ) -> hir::TypeBinding<'hir> { debug!("lower_assoc_ty_constraint(constraint={:?}, itctx={:?})", constraint, itctx); - if let Some(ref gen_args) = constraint.gen_args { - self.sess.span_fatal( - gen_args.span(), - "generic associated types in trait paths are currently not implemented", - ); - } + // lower generic arguments of identifier in constraint + let gen_args = if let Some(ref gen_args) = constraint.gen_args { + let gen_args_ctor = match gen_args { + GenericArgs::AngleBracketed(ref data) => { + self.lower_angle_bracketed_parameter_data( + data, + ParamMode::Explicit, + itctx.reborrow(), + ) + .0 + } + GenericArgs::Parenthesized(ref data) => { + let mut err = self.sess.struct_span_err( + gen_args.span(), + "parenthesized generic arguments cannot be used in associated type constraints" + ); + // FIXME: try to write a suggestion here + err.emit(); + self.lower_angle_bracketed_parameter_data( + &data.as_angle_bracketed_args(), + ParamMode::Explicit, + itctx.reborrow(), + ) + .0 + } + }; + self.arena.alloc(gen_args_ctor.into_generic_args(&self.arena)) + } else { + self.arena.alloc(hir::GenericArgs::none()) + }; let kind = match constraint.kind { AssocTyConstraintKind::Equality { ref ty } => { @@ -1182,6 +1206,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { hir::TypeBinding { hir_id: self.lower_node_id(constraint.id), ident: constraint.ident, + gen_args, kind, span: constraint.span, } diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs index 9079e26eb50..cb4d5ea6ee6 100644 --- a/compiler/rustc_ast_lowering/src/path.rs +++ b/compiler/rustc_ast_lowering/src/path.rs @@ -362,7 +362,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } } - fn lower_angle_bracketed_parameter_data( + pub(crate) fn lower_angle_bracketed_parameter_data( &mut self, data: &AngleBracketedArgs, param_mode: ParamMode, @@ -426,6 +426,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { ) -> hir::TypeBinding<'hir> { let ident = Ident::with_dummy_span(hir::FN_OUTPUT_NAME); let kind = hir::TypeBindingKind::Equality { ty }; - hir::TypeBinding { hir_id: self.next_id(), span, ident, kind } + let args = arena_vec![self;]; + let bindings = arena_vec![self;]; + let gen_args = self.arena.alloc(hir::GenericArgs { args, bindings, parenthesized: false }); + hir::TypeBinding { hir_id: self.next_id(), gen_args, span, ident, kind } } } diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs index 696d5fdd6cd..aca3fbbca13 100644 --- a/compiler/rustc_attr/src/builtin.rs +++ b/compiler/rustc_attr/src/builtin.rs @@ -74,7 +74,7 @@ pub enum InlineAttr { Never, } -#[derive(Clone, Encodable, Decodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq)] pub enum InstructionSetAttr { ArmA32, ArmT32, diff --git a/compiler/rustc_builtin_macros/Cargo.toml b/compiler/rustc_builtin_macros/Cargo.toml index c397a854126..eb022b5b2b1 100644 --- a/compiler/rustc_builtin_macros/Cargo.toml +++ b/compiler/rustc_builtin_macros/Cargo.toml @@ -15,6 +15,7 @@ rustc_attr = { path = "../rustc_attr" } rustc_data_structures = { path = "../rustc_data_structures" } rustc_errors = { path = "../rustc_errors" } rustc_feature = { path = "../rustc_feature" } +rustc_lexer = { path = "../rustc_lexer" } rustc_parse = { path = "../rustc_parse" } rustc_target = { path = "../rustc_target" } rustc_session = { path = "../rustc_session" } diff --git a/compiler/rustc_builtin_macros/src/derive.rs b/compiler/rustc_builtin_macros/src/derive.rs new file mode 100644 index 00000000000..fad64858ce3 --- /dev/null +++ b/compiler/rustc_builtin_macros/src/derive.rs @@ -0,0 +1,132 @@ +use rustc_ast::{self as ast, token, ItemKind, MetaItemKind, NestedMetaItem, StmtKind}; +use rustc_errors::{struct_span_err, Applicability}; +use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt, Indeterminate, MultiItemModifier}; +use rustc_expand::config::StripUnconfigured; +use rustc_feature::AttributeTemplate; +use rustc_parse::validate_attr; +use rustc_session::Session; +use rustc_span::symbol::sym; +use rustc_span::Span; + +crate struct Expander; + +impl MultiItemModifier for Expander { + fn expand( + &self, + ecx: &mut ExtCtxt<'_>, + span: Span, + meta_item: &ast::MetaItem, + item: Annotatable, + ) -> ExpandResult<Vec<Annotatable>, Annotatable> { + let sess = ecx.sess; + if report_bad_target(sess, &item, span) { + // We don't want to pass inappropriate targets to derive macros to avoid + // follow up errors, all other errors below are recoverable. + return ExpandResult::Ready(vec![item]); + } + + let template = + AttributeTemplate { list: Some("Trait1, Trait2, ..."), ..Default::default() }; + let attr = ecx.attribute(meta_item.clone()); + validate_attr::check_builtin_attribute(&sess.parse_sess, &attr, sym::derive, template); + + let derives: Vec<_> = attr + .meta_item_list() + .unwrap_or_default() + .into_iter() + .filter_map(|nested_meta| match nested_meta { + NestedMetaItem::MetaItem(meta) => Some(meta), + NestedMetaItem::Literal(lit) => { + // Reject `#[derive("Debug")]`. + report_unexpected_literal(sess, &lit); + None + } + }) + .map(|meta| { + // Reject `#[derive(Debug = "value", Debug(abc))]`, but recover the paths. + report_path_args(sess, &meta); + meta.path + }) + .collect(); + + // FIXME: Try to cache intermediate results to avoid collecting same paths multiple times. + match ecx.resolver.resolve_derives(ecx.current_expansion.id, derives, ecx.force_mode) { + Ok(()) => { + let mut visitor = + StripUnconfigured { sess, features: ecx.ecfg.features, modified: false }; + let mut item = visitor.fully_configure(item); + if visitor.modified { + // Erase the tokens if cfg-stripping modified the item + // This will cause us to synthesize fake tokens + // when `nt_to_tokenstream` is called on this item. + match &mut item { + Annotatable::Item(item) => item, + Annotatable::Stmt(stmt) => match &mut stmt.kind { + StmtKind::Item(item) => item, + _ => unreachable!(), + }, + _ => unreachable!(), + } + .tokens = None; + } + ExpandResult::Ready(vec![item]) + } + Err(Indeterminate) => ExpandResult::Retry(item), + } + } +} + +fn report_bad_target(sess: &Session, item: &Annotatable, span: Span) -> bool { + let item_kind = match item { + Annotatable::Item(item) => Some(&item.kind), + Annotatable::Stmt(stmt) => match &stmt.kind { + StmtKind::Item(item) => Some(&item.kind), + _ => None, + }, + _ => None, + }; + + let bad_target = + !matches!(item_kind, Some(ItemKind::Struct(..) | ItemKind::Enum(..) | ItemKind::Union(..))); + if bad_target { + struct_span_err!( + sess, + span, + E0774, + "`derive` may only be applied to structs, enums and unions", + ) + .emit(); + } + bad_target +} + +fn report_unexpected_literal(sess: &Session, lit: &ast::Lit) { + let help_msg = match lit.token.kind { + token::Str if rustc_lexer::is_ident(&lit.token.symbol.as_str()) => { + format!("try using `#[derive({})]`", lit.token.symbol) + } + _ => "for example, write `#[derive(Debug)]` for `Debug`".to_string(), + }; + struct_span_err!(sess, lit.span, E0777, "expected path to a trait, found literal",) + .help(&help_msg) + .emit(); +} + +fn report_path_args(sess: &Session, meta: &ast::MetaItem) { + let report_error = |title, action| { + let span = meta.span.with_lo(meta.path.span.hi()); + sess.struct_span_err(span, title) + .span_suggestion(span, action, String::new(), Applicability::MachineApplicable) + .emit(); + }; + match meta.kind { + MetaItemKind::Word => {} + MetaItemKind::List(..) => report_error( + "traits in `#[derive(...)]` don't accept arguments", + "remove the arguments", + ), + MetaItemKind::NameValue(..) => { + report_error("traits in `#[derive(...)]` don't accept values", "remove the value") + } + } +} diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs index 59844b6c692..9a3c914337c 100644 --- a/compiler/rustc_builtin_macros/src/lib.rs +++ b/compiler/rustc_builtin_macros/src/lib.rs @@ -27,6 +27,7 @@ mod cfg_accessible; mod compile_error; mod concat; mod concat_idents; +mod derive; mod deriving; mod env; mod format; @@ -88,6 +89,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) { register_attr! { bench: test::expand_bench, cfg_accessible: cfg_accessible::Expander, + derive: derive::Expander, global_allocator: global_allocator::expand, test: test::expand_test, test_case: test::expand_test_case, diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs index 14dd245625d..16e1a8a1242 100644 --- a/compiler/rustc_codegen_llvm/src/consts.rs +++ b/compiler/rustc_codegen_llvm/src/consts.rs @@ -8,9 +8,7 @@ use crate::value::Value; use libc::c_uint; use rustc_codegen_ssa::traits::*; use rustc_data_structures::const_cstr; -use rustc_hir as hir; use rustc_hir::def_id::DefId; -use rustc_hir::Node; use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs}; use rustc_middle::mir::interpret::{ read_target_uint, Allocation, ErrorHandled, GlobalAlloc, Pointer, @@ -18,7 +16,6 @@ use rustc_middle::mir::interpret::{ use rustc_middle::mir::mono::MonoItem; use rustc_middle::ty::{self, Instance, Ty}; use rustc_middle::{bug, span_bug}; -use rustc_span::symbol::sym; use rustc_target::abi::{AddressSpace, Align, HasDataLayout, LayoutOf, Primitive, Scalar, Size}; use tracing::debug; @@ -209,70 +206,42 @@ impl CodegenCx<'ll, 'tcx> { let ty = instance.ty(self.tcx, ty::ParamEnv::reveal_all()); let sym = self.tcx.symbol_name(instance).name; + let fn_attrs = self.tcx.codegen_fn_attrs(def_id); - debug!("get_static: sym={} instance={:?}", sym, instance); + debug!("get_static: sym={} instance={:?} fn_attrs={:?}", sym, instance, fn_attrs); - let g = if let Some(local_def_id) = def_id.as_local() { - let id = self.tcx.hir().local_def_id_to_hir_id(local_def_id); + let g = if def_id.is_local() && !self.tcx.is_foreign_item(def_id) { let llty = self.layout_of(ty).llvm_type(self); - // FIXME: refactor this to work without accessing the HIR - let (g, attrs) = match self.tcx.hir().get(id) { - Node::Item(&hir::Item { attrs, kind: hir::ItemKind::Static(..), .. }) => { - if let Some(g) = self.get_declared_value(sym) { - if self.val_ty(g) != self.type_ptr_to(llty) { - span_bug!(self.tcx.def_span(def_id), "Conflicting types for static"); - } - } - - let g = self.declare_global(sym, llty); - - if !self.tcx.is_reachable_non_generic(local_def_id) { - unsafe { - llvm::LLVMRustSetVisibility(g, llvm::Visibility::Hidden); - } - } - - (g, attrs) + if let Some(g) = self.get_declared_value(sym) { + if self.val_ty(g) != self.type_ptr_to(llty) { + span_bug!(self.tcx.def_span(def_id), "Conflicting types for static"); } + } - Node::ForeignItem(&hir::ForeignItem { - ref attrs, - kind: hir::ForeignItemKind::Static(..), - .. - }) => { - let fn_attrs = self.tcx.codegen_fn_attrs(local_def_id); - (check_and_apply_linkage(&self, &fn_attrs, ty, sym, def_id), &**attrs) - } - - item => bug!("get_static: expected static, found {:?}", item), - }; - - debug!("get_static: sym={} attrs={:?}", sym, attrs); + let g = self.declare_global(sym, llty); - for attr in attrs { - if self.tcx.sess.check_name(attr, sym::thread_local) { - llvm::set_thread_local_mode(g, self.tls_model); + if !self.tcx.is_reachable_non_generic(def_id) { + unsafe { + llvm::LLVMRustSetVisibility(g, llvm::Visibility::Hidden); } } g } else { - // FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow? - debug!("get_static: sym={} item_attr={:?}", sym, self.tcx.item_attrs(def_id)); + check_and_apply_linkage(&self, &fn_attrs, ty, sym, def_id) + }; - let attrs = self.tcx.codegen_fn_attrs(def_id); - let g = check_and_apply_linkage(&self, &attrs, ty, sym, def_id); - - // Thread-local statics in some other crate need to *always* be linked - // against in a thread-local fashion, so we need to be sure to apply the - // thread-local attribute locally if it was present remotely. If we - // don't do this then linker errors can be generated where the linker - // complains that one object files has a thread local version of the - // symbol and another one doesn't. - if attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) { - llvm::set_thread_local_mode(g, self.tls_model); - } + // Thread-local statics in some other crate need to *always* be linked + // against in a thread-local fashion, so we need to be sure to apply the + // thread-local attribute locally if it was present remotely. If we + // don't do this then linker errors can be generated where the linker + // complains that one object files has a thread local version of the + // symbol and another one doesn't. + if fn_attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) { + llvm::set_thread_local_mode(g, self.tls_model); + } + if !def_id.is_local() { let needs_dll_storage_attr = self.use_dll_storage_attrs && !self.tcx.is_foreign_item(def_id) && // ThinLTO can't handle this workaround in all cases, so we don't // emit the attrs. Instead we make them unnecessary by disallowing @@ -304,8 +273,7 @@ impl CodegenCx<'ll, 'tcx> { } } } - g - }; + } if self.use_dll_storage_attrs && self.tcx.is_dllimport_foreign_item(def_id) { // For foreign (native) libs we know the exact storage type to use. diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs index 6acd26bd415..ee099f93258 100644 --- a/compiler/rustc_codegen_llvm/src/context.rs +++ b/compiler/rustc_codegen_llvm/src/context.rs @@ -380,7 +380,7 @@ impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> { "rust_eh_personality" }; let fty = self.type_variadic_func(&[], self.type_i32()); - self.declare_cfn(name, fty) + self.declare_cfn(name, llvm::UnnamedAddr::Global, fty) } }; attributes::apply_target_cpu_attr(self, llfn); @@ -429,7 +429,7 @@ impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> { fn declare_c_main(&self, fn_type: Self::Type) -> Option<Self::Function> { if self.get_declared_value("main").is_none() { - Some(self.declare_cfn("main", fn_type)) + Some(self.declare_cfn("main", llvm::UnnamedAddr::Global, fn_type)) } else { // If the symbol already exists, it is an error: for example, the user wrote // #[no_mangle] extern "C" fn main(..) {..} @@ -459,8 +459,7 @@ impl CodegenCx<'b, 'tcx> { } else { self.type_variadic_func(&[], ret) }; - let f = self.declare_cfn(name, fn_ty); - llvm::SetUnnamedAddress(f, llvm::UnnamedAddr::No); + let f = self.declare_cfn(name, llvm::UnnamedAddr::No, fn_ty); self.intrinsics.borrow_mut().insert(name, f); f } @@ -498,25 +497,6 @@ impl CodegenCx<'b, 'tcx> { let t_f32 = self.type_f32(); let t_f64 = self.type_f64(); - macro_rules! vector_types { - ($id_out:ident: $elem_ty:ident, $len:expr) => { - let $id_out = self.type_vector($elem_ty, $len); - }; - ($($id_out:ident: $elem_ty:ident, $len:expr;)*) => { - $(vector_types!($id_out: $elem_ty, $len);)* - } - } - vector_types! { - t_v2f32: t_f32, 2; - t_v4f32: t_f32, 4; - t_v8f32: t_f32, 8; - t_v16f32: t_f32, 16; - - t_v2f64: t_f64, 2; - t_v4f64: t_f64, 4; - t_v8f64: t_f64, 8; - } - ifn!("llvm.wasm.trunc.saturate.unsigned.i32.f32", fn(t_f32) -> t_i32); ifn!("llvm.wasm.trunc.saturate.unsigned.i32.f64", fn(t_f64) -> t_i32); ifn!("llvm.wasm.trunc.saturate.unsigned.i64.f32", fn(t_f32) -> t_i64); @@ -540,124 +520,40 @@ impl CodegenCx<'b, 'tcx> { ifn!("llvm.sideeffect", fn() -> void); ifn!("llvm.powi.f32", fn(t_f32, t_i32) -> t_f32); - ifn!("llvm.powi.v2f32", fn(t_v2f32, t_i32) -> t_v2f32); - ifn!("llvm.powi.v4f32", fn(t_v4f32, t_i32) -> t_v4f32); - ifn!("llvm.powi.v8f32", fn(t_v8f32, t_i32) -> t_v8f32); - ifn!("llvm.powi.v16f32", fn(t_v16f32, t_i32) -> t_v16f32); ifn!("llvm.powi.f64", fn(t_f64, t_i32) -> t_f64); - ifn!("llvm.powi.v2f64", fn(t_v2f64, t_i32) -> t_v2f64); - ifn!("llvm.powi.v4f64", fn(t_v4f64, t_i32) -> t_v4f64); - ifn!("llvm.powi.v8f64", fn(t_v8f64, t_i32) -> t_v8f64); ifn!("llvm.pow.f32", fn(t_f32, t_f32) -> t_f32); - ifn!("llvm.pow.v2f32", fn(t_v2f32, t_v2f32) -> t_v2f32); - ifn!("llvm.pow.v4f32", fn(t_v4f32, t_v4f32) -> t_v4f32); - ifn!("llvm.pow.v8f32", fn(t_v8f32, t_v8f32) -> t_v8f32); - ifn!("llvm.pow.v16f32", fn(t_v16f32, t_v16f32) -> t_v16f32); ifn!("llvm.pow.f64", fn(t_f64, t_f64) -> t_f64); - ifn!("llvm.pow.v2f64", fn(t_v2f64, t_v2f64) -> t_v2f64); - ifn!("llvm.pow.v4f64", fn(t_v4f64, t_v4f64) -> t_v4f64); - ifn!("llvm.pow.v8f64", fn(t_v8f64, t_v8f64) -> t_v8f64); ifn!("llvm.sqrt.f32", fn(t_f32) -> t_f32); - ifn!("llvm.sqrt.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.sqrt.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.sqrt.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.sqrt.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.sqrt.f64", fn(t_f64) -> t_f64); - ifn!("llvm.sqrt.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.sqrt.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.sqrt.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.sin.f32", fn(t_f32) -> t_f32); - ifn!("llvm.sin.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.sin.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.sin.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.sin.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.sin.f64", fn(t_f64) -> t_f64); - ifn!("llvm.sin.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.sin.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.sin.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.cos.f32", fn(t_f32) -> t_f32); - ifn!("llvm.cos.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.cos.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.cos.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.cos.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.cos.f64", fn(t_f64) -> t_f64); - ifn!("llvm.cos.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.cos.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.cos.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.exp.f32", fn(t_f32) -> t_f32); - ifn!("llvm.exp.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.exp.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.exp.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.exp.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.exp.f64", fn(t_f64) -> t_f64); - ifn!("llvm.exp.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.exp.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.exp.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.exp2.f32", fn(t_f32) -> t_f32); - ifn!("llvm.exp2.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.exp2.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.exp2.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.exp2.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.exp2.f64", fn(t_f64) -> t_f64); - ifn!("llvm.exp2.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.exp2.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.exp2.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.log.f32", fn(t_f32) -> t_f32); - ifn!("llvm.log.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.log.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.log.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.log.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.log.f64", fn(t_f64) -> t_f64); - ifn!("llvm.log.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.log.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.log.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.log10.f32", fn(t_f32) -> t_f32); - ifn!("llvm.log10.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.log10.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.log10.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.log10.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.log10.f64", fn(t_f64) -> t_f64); - ifn!("llvm.log10.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.log10.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.log10.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.log2.f32", fn(t_f32) -> t_f32); - ifn!("llvm.log2.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.log2.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.log2.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.log2.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.log2.f64", fn(t_f64) -> t_f64); - ifn!("llvm.log2.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.log2.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.log2.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.fma.f32", fn(t_f32, t_f32, t_f32) -> t_f32); - ifn!("llvm.fma.v2f32", fn(t_v2f32, t_v2f32, t_v2f32) -> t_v2f32); - ifn!("llvm.fma.v4f32", fn(t_v4f32, t_v4f32, t_v4f32) -> t_v4f32); - ifn!("llvm.fma.v8f32", fn(t_v8f32, t_v8f32, t_v8f32) -> t_v8f32); - ifn!("llvm.fma.v16f32", fn(t_v16f32, t_v16f32, t_v16f32) -> t_v16f32); ifn!("llvm.fma.f64", fn(t_f64, t_f64, t_f64) -> t_f64); - ifn!("llvm.fma.v2f64", fn(t_v2f64, t_v2f64, t_v2f64) -> t_v2f64); - ifn!("llvm.fma.v4f64", fn(t_v4f64, t_v4f64, t_v4f64) -> t_v4f64); - ifn!("llvm.fma.v8f64", fn(t_v8f64, t_v8f64, t_v8f64) -> t_v8f64); ifn!("llvm.fabs.f32", fn(t_f32) -> t_f32); - ifn!("llvm.fabs.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.fabs.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.fabs.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.fabs.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.fabs.f64", fn(t_f64) -> t_f64); - ifn!("llvm.fabs.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.fabs.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.fabs.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.minnum.f32", fn(t_f32, t_f32) -> t_f32); ifn!("llvm.minnum.f64", fn(t_f64, t_f64) -> t_f64); @@ -665,24 +561,10 @@ impl CodegenCx<'b, 'tcx> { ifn!("llvm.maxnum.f64", fn(t_f64, t_f64) -> t_f64); ifn!("llvm.floor.f32", fn(t_f32) -> t_f32); - ifn!("llvm.floor.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.floor.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.floor.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.floor.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.floor.f64", fn(t_f64) -> t_f64); - ifn!("llvm.floor.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.floor.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.floor.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.ceil.f32", fn(t_f32) -> t_f32); - ifn!("llvm.ceil.v2f32", fn(t_v2f32) -> t_v2f32); - ifn!("llvm.ceil.v4f32", fn(t_v4f32) -> t_v4f32); - ifn!("llvm.ceil.v8f32", fn(t_v8f32) -> t_v8f32); - ifn!("llvm.ceil.v16f32", fn(t_v16f32) -> t_v16f32); ifn!("llvm.ceil.f64", fn(t_f64) -> t_f64); - ifn!("llvm.ceil.v2f64", fn(t_v2f64) -> t_v2f64); - ifn!("llvm.ceil.v4f64", fn(t_v4f64) -> t_v4f64); - ifn!("llvm.ceil.v8f64", fn(t_v8f64) -> t_v8f64); ifn!("llvm.trunc.f32", fn(t_f32) -> t_f32); ifn!("llvm.trunc.f64", fn(t_f64) -> t_f64); diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs index 0591e0a5c12..8977fa085b9 100644 --- a/compiler/rustc_codegen_llvm/src/declare.rs +++ b/compiler/rustc_codegen_llvm/src/declare.rs @@ -30,6 +30,7 @@ fn declare_raw_fn( cx: &CodegenCx<'ll, '_>, name: &str, callconv: llvm::CallConv, + unnamed: llvm::UnnamedAddr, ty: &'ll Type, ) -> &'ll Value { debug!("declare_raw_fn(name={:?}, ty={:?})", name, ty); @@ -38,9 +39,7 @@ fn declare_raw_fn( }; llvm::SetFunctionCallConv(llfn, callconv); - // Function addresses in Rust are never significant, allowing functions to - // be merged. - llvm::SetUnnamedAddress(llfn, llvm::UnnamedAddr::Global); + llvm::SetUnnamedAddress(llfn, unnamed); if cx.tcx.sess.opts.cg.no_redzone.unwrap_or(cx.tcx.sess.target.disable_redzone) { llvm::Attribute::NoRedZone.apply_llfn(Function, llfn); @@ -68,8 +67,13 @@ impl CodegenCx<'ll, 'tcx> { /// /// If there’s a value with the same name already declared, the function will /// update the declaration and return existing Value instead. - pub fn declare_cfn(&self, name: &str, fn_type: &'ll Type) -> &'ll Value { - declare_raw_fn(self, name, llvm::CCallConv, fn_type) + pub fn declare_cfn( + &self, + name: &str, + unnamed: llvm::UnnamedAddr, + fn_type: &'ll Type, + ) -> &'ll Value { + declare_raw_fn(self, name, llvm::CCallConv, unnamed, fn_type) } /// Declare a Rust function. @@ -79,7 +83,15 @@ impl CodegenCx<'ll, 'tcx> { pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> &'ll Value { debug!("declare_rust_fn(name={:?}, fn_abi={:?})", name, fn_abi); - let llfn = declare_raw_fn(self, name, fn_abi.llvm_cconv(), fn_abi.llvm_type(self)); + // Function addresses in Rust are never significant, allowing functions to + // be merged. + let llfn = declare_raw_fn( + self, + name, + fn_abi.llvm_cconv(), + llvm::UnnamedAddr::Global, + fn_abi.llvm_type(self), + ); fn_abi.apply_attrs_llfn(self, llfn); llfn } diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index bf0d499e6c4..668daa52ed2 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -1009,7 +1009,7 @@ fn generic_simd_intrinsic( } fn simd_simple_float_intrinsic( - name: &str, + name: Symbol, in_elem: &::rustc_middle::ty::TyS<'_>, in_ty: &::rustc_middle::ty::TyS<'_>, in_len: u64, @@ -1036,93 +1036,69 @@ fn generic_simd_intrinsic( } } } - let ety = match in_elem.kind() { - ty::Float(f) if f.bit_width() == 32 => { - if in_len < 2 || in_len > 16 { - return_error!( - "unsupported floating-point vector `{}` with length `{}` \ - out-of-range [2, 16]", - in_ty, - in_len - ); - } - "f32" - } - ty::Float(f) if f.bit_width() == 64 => { - if in_len < 2 || in_len > 8 { + + let (elem_ty_str, elem_ty) = if let ty::Float(f) = in_elem.kind() { + let elem_ty = bx.cx.type_float_from_ty(*f); + match f.bit_width() { + 32 => ("f32", elem_ty), + 64 => ("f64", elem_ty), + _ => { return_error!( - "unsupported floating-point vector `{}` with length `{}` \ - out-of-range [2, 8]", - in_ty, - in_len + "unsupported element type `{}` of floating-point vector `{}`", + f.name_str(), + in_ty ); } - "f64" - } - ty::Float(f) => { - return_error!( - "unsupported element type `{}` of floating-point vector `{}`", - f.name_str(), - in_ty - ); - } - _ => { - return_error!("`{}` is not a floating-point type", in_ty); } + } else { + return_error!("`{}` is not a floating-point type", in_ty); }; - let llvm_name = &format!("llvm.{0}.v{1}{2}", name, in_len, ety); - let intrinsic = bx.get_intrinsic(&llvm_name); - let c = - bx.call(intrinsic, &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(), None); + let vec_ty = bx.type_vector(elem_ty, in_len); + + let (intr_name, fn_ty) = match name { + sym::simd_fsqrt => ("sqrt", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_fsin => ("sin", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_fcos => ("cos", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_fabs => ("fabs", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_floor => ("floor", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_ceil => ("ceil", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_fexp => ("exp", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_fexp2 => ("exp2", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_flog10 => ("log10", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_flog2 => ("log2", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_flog => ("log", bx.type_func(&[vec_ty], vec_ty)), + sym::simd_fpowi => ("powi", bx.type_func(&[vec_ty, bx.type_i32()], vec_ty)), + sym::simd_fpow => ("pow", bx.type_func(&[vec_ty, vec_ty], vec_ty)), + sym::simd_fma => ("fma", bx.type_func(&[vec_ty, vec_ty, vec_ty], vec_ty)), + _ => return_error!("unrecognized intrinsic `{}`", name), + }; + + let llvm_name = &format!("llvm.{0}.v{1}{2}", intr_name, in_len, elem_ty_str); + let f = bx.declare_cfn(&llvm_name, llvm::UnnamedAddr::No, fn_ty); + let c = bx.call(f, &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(), None); unsafe { llvm::LLVMRustSetHasUnsafeAlgebra(c) }; Ok(c) } - match name { - sym::simd_fsqrt => { - return simd_simple_float_intrinsic("sqrt", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fsin => { - return simd_simple_float_intrinsic("sin", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fcos => { - return simd_simple_float_intrinsic("cos", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fabs => { - return simd_simple_float_intrinsic("fabs", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_floor => { - return simd_simple_float_intrinsic("floor", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_ceil => { - return simd_simple_float_intrinsic("ceil", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fexp => { - return simd_simple_float_intrinsic("exp", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fexp2 => { - return simd_simple_float_intrinsic("exp2", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_flog10 => { - return simd_simple_float_intrinsic("log10", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_flog2 => { - return simd_simple_float_intrinsic("log2", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_flog => { - return simd_simple_float_intrinsic("log", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fpowi => { - return simd_simple_float_intrinsic("powi", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fpow => { - return simd_simple_float_intrinsic("pow", in_elem, in_ty, in_len, bx, span, args); - } - sym::simd_fma => { - return simd_simple_float_intrinsic("fma", in_elem, in_ty, in_len, bx, span, args); - } - _ => { /* fallthrough */ } + if std::matches!( + name, + sym::simd_fsqrt + | sym::simd_fsin + | sym::simd_fcos + | sym::simd_fabs + | sym::simd_floor + | sym::simd_ceil + | sym::simd_fexp + | sym::simd_fexp2 + | sym::simd_flog10 + | sym::simd_flog2 + | sym::simd_flog + | sym::simd_fpowi + | sym::simd_fpow + | sym::simd_fma + ) { + return simd_simple_float_intrinsic(name, in_elem, in_ty, in_len, bx, span, args); } // FIXME: use: @@ -1278,12 +1254,12 @@ fn generic_simd_intrinsic( format!("llvm.masked.gather.{}.{}", llvm_elem_vec_str, llvm_pointer_vec_str); let f = bx.declare_cfn( &llvm_intrinsic, + llvm::UnnamedAddr::No, bx.type_func( &[llvm_pointer_vec_ty, alignment_ty, mask_ty, llvm_elem_vec_ty], llvm_elem_vec_ty, ), ); - llvm::SetUnnamedAddress(f, llvm::UnnamedAddr::No); let v = bx.call(f, &[args[1].immediate(), alignment, mask, args[0].immediate()], None); return Ok(v); } @@ -1408,9 +1384,9 @@ fn generic_simd_intrinsic( format!("llvm.masked.scatter.{}.{}", llvm_elem_vec_str, llvm_pointer_vec_str); let f = bx.declare_cfn( &llvm_intrinsic, + llvm::UnnamedAddr::No, bx.type_func(&[llvm_elem_vec_ty, llvm_pointer_vec_ty, alignment_ty, mask_ty], ret_t), ); - llvm::SetUnnamedAddress(f, llvm::UnnamedAddr::No); let v = bx.call(f, &[args[0].immediate(), args[1].immediate(), alignment, mask], None); return Ok(v); } @@ -1714,8 +1690,11 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#, ); let vec_ty = bx.cx.type_vector(elem_ty, in_len as u64); - let f = bx.declare_cfn(&llvm_intrinsic, bx.type_func(&[vec_ty, vec_ty], vec_ty)); - llvm::SetUnnamedAddress(f, llvm::UnnamedAddr::No); + let f = bx.declare_cfn( + &llvm_intrinsic, + llvm::UnnamedAddr::No, + bx.type_func(&[vec_ty, vec_ty], vec_ty), + ); let v = bx.call(f, &[lhs, rhs], None); return Ok(v); } diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml index e5df0f60941..835f9062399 100644 --- a/compiler/rustc_codegen_ssa/Cargo.toml +++ b/compiler/rustc_codegen_ssa/Cargo.toml @@ -10,6 +10,7 @@ test = false [dependencies] bitflags = "1.2.1" cc = "1.0.1" +itertools = "0.9" num_cpus = "1.0" memmap = "0.7" tracing = "0.1" diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs index 0fc11c286f8..658ad3c375d 100644 --- a/compiler/rustc_codegen_ssa/src/base.rs +++ b/compiler/rustc_codegen_ssa/src/base.rs @@ -32,10 +32,11 @@ use rustc_session::config::{self, EntryFnType}; use rustc_session::Session; use rustc_target::abi::{Align, LayoutOf, VariantIdx}; -use std::cmp; use std::ops::{Deref, DerefMut}; use std::time::{Duration, Instant}; +use itertools::Itertools; + pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind, signed: bool) -> IntPredicate { match op { hir::BinOpKind::Eq => IntPredicate::IntEQ, @@ -546,12 +547,23 @@ pub fn codegen_crate<B: ExtraBackendMethods>( ongoing_codegen.submit_pre_codegened_module_to_llvm(tcx, metadata_module); } - // We sort the codegen units by size. This way we can schedule work for LLVM - // a bit more efficiently. - let codegen_units = { - let mut codegen_units = codegen_units.iter().collect::<Vec<_>>(); - codegen_units.sort_by_cached_key(|cgu| cmp::Reverse(cgu.size_estimate())); - codegen_units + // For better throughput during parallel processing by LLVM, we used to sort + // CGUs largest to smallest. This would lead to better thread utilization + // by, for example, preventing a large CGU from being processed last and + // having only one LLVM thread working while the rest remained idle. + // + // However, this strategy would lead to high memory usage, as it meant the + // LLVM-IR for all of the largest CGUs would be resident in memory at once. + // + // Instead, we can compromise by ordering CGUs such that the largest and + // smallest are first, second largest and smallest are next, etc. If there + // are large size variations, this can reduce memory usage significantly. + let codegen_units: Vec<_> = { + let mut sorted_cgus = codegen_units.iter().collect::<Vec<_>>(); + sorted_cgus.sort_by_cached_key(|cgu| cgu.size_estimate()); + + let (first_half, second_half) = sorted_cgus.split_at(sorted_cgus.len() / 2); + second_half.iter().rev().interleave(first_half).copied().collect() }; // The non-parallel compiler can only translate codegen units to LLVM IR diff --git a/compiler/rustc_data_structures/src/profiling.rs b/compiler/rustc_data_structures/src/profiling.rs index 9a85b9d02c9..f0b413c795e 100644 --- a/compiler/rustc_data_structures/src/profiling.rs +++ b/compiler/rustc_data_structures/src/profiling.rs @@ -590,24 +590,21 @@ pub fn print_time_passes_entry( end_rss: Option<usize>, ) { let rss_to_mb = |rss| (rss as f64 / 1_000_000.0).round() as usize; + let rss_change_to_mb = |rss| (rss as f64 / 1_000_000.0).round() as i128; let mem_string = match (start_rss, end_rss) { (Some(start_rss), Some(end_rss)) => { - // It's tempting to add the change in RSS from start to end, but its somewhat confusing - // and misleading when looking at time-passes output. Consider two adjacent entries: - // - // time: 10.000; rss start: 1000MB, end: 1000MB, change: 0MB pass1 - // time: 5.000; rss start: 2000MB, end: 2000MB, change: 0MB pass2 - // - // If you're looking for jumps in RSS based on the change column, you miss the fact - // that a 1GB jump happened between pass1 and pass2 (supposing pass1 and pass2 actually - // occur sequentially and pass1 isn't just nested within pass2). It's easy to imagine - // someone missing this or being confused by the fact that the change is zero. - - format!("; rss: {:>5}MB -> {:>5}MB", rss_to_mb(start_rss), rss_to_mb(end_rss)) + let change_rss = end_rss as i128 - start_rss as i128; + + format!( + "; rss: {:>4}MB -> {:>4}MB ({:>+5}MB)", + rss_to_mb(start_rss), + rss_to_mb(end_rss), + rss_change_to_mb(change_rss), + ) } - (Some(start_rss), None) => format!("; rss start: {:>5}MB", rss_to_mb(start_rss)), - (None, Some(end_rss)) => format!("; rss end: {:5>}MB", rss_to_mb(end_rss)), + (Some(start_rss), None) => format!("; rss start: {:>4}MB", rss_to_mb(start_rss)), + (None, Some(end_rss)) => format!("; rss end: {:>4}MB", rss_to_mb(end_rss)), (None, None) => String::new(), }; diff --git a/compiler/rustc_error_codes/src/error_codes.rs b/compiler/rustc_error_codes/src/error_codes.rs index 1ed43669ad8..849ef18fb90 100644 --- a/compiler/rustc_error_codes/src/error_codes.rs +++ b/compiler/rustc_error_codes/src/error_codes.rs @@ -285,6 +285,7 @@ E0537: include_str!("./error_codes/E0537.md"), E0538: include_str!("./error_codes/E0538.md"), E0539: include_str!("./error_codes/E0539.md"), E0541: include_str!("./error_codes/E0541.md"), +E0542: include_str!("./error_codes/E0542.md"), E0546: include_str!("./error_codes/E0546.md"), E0550: include_str!("./error_codes/E0550.md"), E0551: include_str!("./error_codes/E0551.md"), @@ -602,7 +603,6 @@ E0781: include_str!("./error_codes/E0781.md"), E0523, // E0526, // shuffle indices are not constant // E0540, // multiple rustc_deprecated attributes - E0542, // missing 'since' E0543, // missing 'reason' E0544, // multiple stability levels E0545, // incorrect 'issue' diff --git a/compiler/rustc_error_codes/src/error_codes/E0074.md b/compiler/rustc_error_codes/src/error_codes/E0074.md index e25dec7681b..785d6de226d 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0074.md +++ b/compiler/rustc_error_codes/src/error_codes/E0074.md @@ -11,7 +11,7 @@ This will cause an error: #![feature(repr_simd)] #[repr(simd)] -struct Bad<T>(T, T, T); +struct Bad<T>(T, T, T, T); ``` This will not: @@ -20,5 +20,5 @@ This will not: #![feature(repr_simd)] #[repr(simd)] -struct Good(u32, u32, u32); +struct Good(u32, u32, u32, u32); ``` diff --git a/compiler/rustc_error_codes/src/error_codes/E0076.md b/compiler/rustc_error_codes/src/error_codes/E0076.md index f293a2a5772..1da8caa9506 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0076.md +++ b/compiler/rustc_error_codes/src/error_codes/E0076.md @@ -7,7 +7,7 @@ Erroneous code example: #![feature(repr_simd)] #[repr(simd)] -struct Bad(u16, u32, u32); // error! +struct Bad(u16, u32, u32 u32); // error! ``` When using the `#[simd]` attribute to automatically use SIMD operations in tuple @@ -20,5 +20,5 @@ Fixed example: #![feature(repr_simd)] #[repr(simd)] -struct Good(u32, u32, u32); // ok! +struct Good(u32, u32, u32, u32); // ok! ``` diff --git a/compiler/rustc_error_codes/src/error_codes/E0077.md b/compiler/rustc_error_codes/src/error_codes/E0077.md index b14513c6ccf..91aa24d1f52 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0077.md +++ b/compiler/rustc_error_codes/src/error_codes/E0077.md @@ -19,5 +19,5 @@ Fixed example: #![feature(repr_simd)] #[repr(simd)] -struct Good(u32, u32, u32); // ok! +struct Good(u32, u32, u32, u32); // ok! ``` diff --git a/compiler/rustc_error_codes/src/error_codes/E0463.md b/compiler/rustc_error_codes/src/error_codes/E0463.md index e46938c607d..d0cd1b1dcb7 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0463.md +++ b/compiler/rustc_error_codes/src/error_codes/E0463.md @@ -11,3 +11,24 @@ extern crate cake_is_a_lie; // error: can't find crate for `cake_is_a_lie` You need to link your code to the relevant crate in order to be able to use it (through Cargo or the `-L` option of rustc example). Plugins are crates as well, and you link to them the same way. + +## Common causes + +- The crate is not present at all. If using Cargo, add it to `[dependencies]` + in Cargo.toml. +- The crate is present, but under a different name. If using Cargo, look for + `package = ` under `[dependencies]` in Cargo.toml. + +## Common causes for missing `std` or `core` + +- You are cross-compiling for a target which doesn't have `std` prepackaged. + Consider one of the following: + + Adding a pre-compiled version of std with `rustup target add` + + Building std from source with `cargo build -Z build-std` + + Using `#![no_std]` at the crate root, so you won't need `std` in the first + place. +- You are developing the compiler itself and haven't built libstd from source. + You can usually build it with `x.py build library/std`. More information + about x.py is available in the [rustc-dev-guide]. + +[rustc-dev-guide]: https://rustc-dev-guide.rust-lang.org/building/how-to-build-and-run.html#building-the-compiler diff --git a/compiler/rustc_error_codes/src/error_codes/E0542.md b/compiler/rustc_error_codes/src/error_codes/E0542.md new file mode 100644 index 00000000000..dbbc34a71be --- /dev/null +++ b/compiler/rustc_error_codes/src/error_codes/E0542.md @@ -0,0 +1,47 @@ +The `since` value is missing in a stability attribute. + +Erroneous code example: + +```compile_fail,E0542 +#![feature(staged_api)] +#![stable(since = "1.0.0", feature = "test")] + +#[stable(feature = "_stable_fn")] // invalid +fn _stable_fn() {} + +#[rustc_const_stable(feature = "_stable_const_fn")] // invalid +fn _stable_const_fn() {} + +#[stable(feature = "_deprecated_fn", since = "0.1.0")] +#[rustc_deprecated( + reason = "explanation for deprecation" +)] // invalid +fn _deprecated_fn() {} +``` + +To fix the issue you need to provide the `since` field. + +``` +#![feature(staged_api)] +#![stable(since = "1.0.0", feature = "test")] + +#[stable(feature = "_stable_fn", since = "1.0.0")] // ok! +fn _stable_fn() {} + +#[rustc_const_stable(feature = "_stable_const_fn", since = "1.0.0")] // ok! +fn _stable_const_fn() {} + +#[stable(feature = "_deprecated_fn", since = "0.1.0")] +#[rustc_deprecated( + since = "1.0.0", + reason = "explanation for deprecation" +)] // ok! +fn _deprecated_fn() {} +``` + +See the [How Rust is Made and “Nightly Rust”][how-rust-made-nightly] appendix +of the Book and the [Stability attributes][stability-attributes] section of the +Rustc Dev Guide for more details. + +[how-rust-made-nightly]: https://doc.rust-lang.org/book/appendix-07-nightly-rust.html +[stability-attributes]: https://rustc-dev-guide.rust-lang.org/stability.html diff --git a/compiler/rustc_error_codes/src/error_codes/E0546.md b/compiler/rustc_error_codes/src/error_codes/E0546.md index b2df22c0f8f..0073357b5ea 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0546.md +++ b/compiler/rustc_error_codes/src/error_codes/E0546.md @@ -1,4 +1,4 @@ -A feature name is missing. +The `feature` value is missing in a stability attribute. Erroneous code example: @@ -13,7 +13,7 @@ fn unstable_fn() {} fn stable_fn() {} ``` -To fix the issue you need to provide a feature name. +To fix the issue you need to provide the `feature` field. ``` #![feature(staged_api)] @@ -25,3 +25,10 @@ fn unstable_fn() {} #[stable(feature = "stable_fn", since = "1.0.0")] // ok! fn stable_fn() {} ``` + +See the [How Rust is Made and “Nightly Rust”][how-rust-made-nightly] appendix +of the Book and the [Stability attributes][stability-attributes] section of the +Rustc Dev Guide for more details. + +[how-rust-made-nightly]: https://doc.rust-lang.org/book/appendix-07-nightly-rust.html +[stability-attributes]: https://rustc-dev-guide.rust-lang.org/stability.html diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs index e61476bf23e..ef4a45cab41 100644 --- a/compiler/rustc_errors/src/diagnostic.rs +++ b/compiler/rustc_errors/src/diagnostic.rs @@ -4,7 +4,9 @@ use crate::Level; use crate::Substitution; use crate::SubstitutionPart; use crate::SuggestionStyle; +use crate::ToolMetadata; use rustc_lint_defs::Applicability; +use rustc_serialize::json::Json; use rustc_span::{MultiSpan, Span, DUMMY_SP}; use std::fmt; @@ -303,6 +305,7 @@ impl Diagnostic { msg: msg.to_owned(), style: SuggestionStyle::ShowCode, applicability, + tool_metadata: Default::default(), }); self } @@ -328,6 +331,7 @@ impl Diagnostic { msg: msg.to_owned(), style: SuggestionStyle::ShowCode, applicability, + tool_metadata: Default::default(), }); self } @@ -354,6 +358,7 @@ impl Diagnostic { msg: msg.to_owned(), style: SuggestionStyle::CompletelyHidden, applicability, + tool_metadata: Default::default(), }); self } @@ -408,6 +413,7 @@ impl Diagnostic { msg: msg.to_owned(), style, applicability, + tool_metadata: Default::default(), }); self } @@ -446,6 +452,7 @@ impl Diagnostic { msg: msg.to_owned(), style: SuggestionStyle::ShowCode, applicability, + tool_metadata: Default::default(), }); self } @@ -515,6 +522,23 @@ impl Diagnostic { self } + /// Adds a suggestion intended only for a tool. The intent is that the metadata encodes + /// the suggestion in a tool-specific way, as it may not even directly involve Rust code. + pub fn tool_only_suggestion_with_metadata( + &mut self, + msg: &str, + applicability: Applicability, + tool_metadata: Json, + ) { + self.suggestions.push(CodeSuggestion { + substitutions: vec![], + msg: msg.to_owned(), + style: SuggestionStyle::CompletelyHidden, + applicability, + tool_metadata: ToolMetadata::new(tool_metadata), + }) + } + pub fn set_span<S: Into<MultiSpan>>(&mut self, sp: S) -> &mut Self { self.span = sp.into(); if let Some(span) = self.span.primary_span() { diff --git a/compiler/rustc_errors/src/json.rs b/compiler/rustc_errors/src/json.rs index d57beb1148a..c27b39a9d62 100644 --- a/compiler/rustc_errors/src/json.rs +++ b/compiler/rustc_errors/src/json.rs @@ -14,6 +14,7 @@ use rustc_span::source_map::{FilePathMapping, SourceMap}; use crate::emitter::{Emitter, HumanReadableErrorType}; use crate::registry::Registry; use crate::DiagnosticId; +use crate::ToolMetadata; use crate::{CodeSuggestion, SubDiagnostic}; use rustc_lint_defs::{Applicability, FutureBreakage}; @@ -26,6 +27,7 @@ use std::sync::{Arc, Mutex}; use std::vec; use rustc_serialize::json::{as_json, as_pretty_json}; +use rustc_serialize::{Encodable, Encoder}; #[cfg(test)] mod tests; @@ -168,7 +170,8 @@ impl Emitter for JsonEmitter { // The following data types are provided just for serialisation. -#[derive(Encodable)] +// NOTE: this has a manual implementation of Encodable which needs to be updated in +// parallel. struct Diagnostic { /// The primary error message. message: String, @@ -180,6 +183,65 @@ struct Diagnostic { children: Vec<Diagnostic>, /// The message as rustc would render it. rendered: Option<String>, + /// Extra tool metadata + tool_metadata: ToolMetadata, +} + +macro_rules! encode_fields { + ( + $enc:expr, // encoder + $idx:expr, // starting field index + $struct:expr, // struct we're serializing + $struct_name:ident, // struct name + [ $($name:ident),+$(,)? ], // fields to encode + [ $($ignore:ident),+$(,)? ] // fields we're skipping + ) => { + { + // Pattern match to make sure all fields are accounted for + let $struct_name { $($name,)+ $($ignore: _,)+ } = $struct; + let mut idx = $idx; + $( + $enc.emit_struct_field( + stringify!($name), + idx, + |enc| $name.encode(enc), + )?; + idx += 1; + )+ + idx + } + }; +} + +// Special-case encoder to skip tool_metadata if not set +impl<E: Encoder> Encodable<E> for Diagnostic { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.emit_struct("diagnostic", 7, |s| { + let mut idx = 0; + + idx = encode_fields!( + s, + idx, + self, + Self, + [message, code, level, spans, children, rendered], + [tool_metadata] + ); + if self.tool_metadata.is_set() { + idx = encode_fields!( + s, + idx, + self, + Self, + [tool_metadata], + [message, code, level, spans, children, rendered] + ); + } + + let _ = idx; + Ok(()) + }) + } } #[derive(Encodable)] @@ -269,6 +331,7 @@ impl Diagnostic { spans: DiagnosticSpan::from_suggestion(sugg, je), children: vec![], rendered: None, + tool_metadata: sugg.tool_metadata.clone(), }); // generate regular command line output and store it in the json @@ -312,6 +375,7 @@ impl Diagnostic { .chain(sugg) .collect(), rendered: Some(output), + tool_metadata: ToolMetadata::default(), } } @@ -327,6 +391,7 @@ impl Diagnostic { .unwrap_or_else(|| DiagnosticSpan::from_multispan(&diag.span, je)), children: vec![], rendered: None, + tool_metadata: ToolMetadata::default(), } } } diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index aa882332099..9800ed9bfa9 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -23,10 +23,13 @@ use rustc_data_structures::sync::{self, Lock, Lrc}; use rustc_data_structures::AtomicRef; use rustc_lint_defs::FutureBreakage; pub use rustc_lint_defs::{pluralize, Applicability}; +use rustc_serialize::json::Json; +use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; use rustc_span::source_map::SourceMap; use rustc_span::{Loc, MultiSpan, Span}; use std::borrow::Cow; +use std::hash::{Hash, Hasher}; use std::panic; use std::path::Path; use std::{error, fmt}; @@ -73,6 +76,39 @@ impl SuggestionStyle { } } +#[derive(Clone, Debug, PartialEq, Default)] +pub struct ToolMetadata(pub Option<Json>); + +impl ToolMetadata { + fn new(json: Json) -> Self { + ToolMetadata(Some(json)) + } + + fn is_set(&self) -> bool { + self.0.is_some() + } +} + +impl Hash for ToolMetadata { + fn hash<H: Hasher>(&self, _state: &mut H) {} +} + +// Doesn't really need to round-trip +impl<D: Decoder> Decodable<D> for ToolMetadata { + fn decode(_d: &mut D) -> Result<Self, D::Error> { + Ok(ToolMetadata(None)) + } +} + +impl<S: Encoder> Encodable<S> for ToolMetadata { + fn encode(&self, e: &mut S) -> Result<(), S::Error> { + match &self.0 { + None => e.emit_unit(), + Some(json) => json.encode(e), + } + } +} + #[derive(Clone, Debug, PartialEq, Hash, Encodable, Decodable)] pub struct CodeSuggestion { /// Each substitute can have multiple variants due to multiple @@ -106,6 +142,8 @@ pub struct CodeSuggestion { /// which are useful for users but not useful for /// tools like rustfix pub applicability: Applicability, + /// Tool-specific metadata + pub tool_metadata: ToolMetadata, } #[derive(Clone, Debug, PartialEq, Hash, Encodable, Decodable)] @@ -775,7 +813,6 @@ impl HandlerInner { } let already_emitted = |this: &mut Self| { - use std::hash::Hash; let mut hasher = StableHasher::new(); diagnostic.hash(&mut hasher); let diagnostic_hash = hasher.finish(); diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs index 08543d1622a..196a774355e 100644 --- a/compiler/rustc_expand/src/base.rs +++ b/compiler/rustc_expand/src/base.rs @@ -141,7 +141,10 @@ impl Annotatable { } crate fn into_tokens(self, sess: &ParseSess) -> TokenStream { - nt_to_tokenstream(&self.into_nonterminal(), sess, CanSynthesizeMissingTokens::No) + // Tokens of an attribute target may be invalidated by some outer `#[derive]` performing + // "full configuration" (attributes following derives on the same item should be the most + // common case), that's why synthesizing tokens is allowed. + nt_to_tokenstream(&self.into_nonterminal(), sess, CanSynthesizeMissingTokens::Yes) } pub fn expect_item(self) -> P<ast::Item> { @@ -234,25 +237,6 @@ impl Annotatable { _ => panic!("expected variant"), } } - - pub fn derive_allowed(&self) -> bool { - match *self { - Annotatable::Stmt(ref stmt) => match stmt.kind { - ast::StmtKind::Item(ref item) => matches!( - item.kind, - ast::ItemKind::Struct(..) | ast::ItemKind::Enum(..) | ast::ItemKind::Union(..) - ), - _ => false, - }, - Annotatable::Item(ref item) => match item.kind { - ast::ItemKind::Struct(..) | ast::ItemKind::Enum(..) | ast::ItemKind::Union(..) => { - true - } - _ => false, - }, - _ => false, - } - } } /// Result of an expansion that may need to be retried. @@ -854,12 +838,6 @@ impl SyntaxExtension { } } -/// Result of resolving a macro invocation. -pub enum InvocationRes { - Single(Lrc<SyntaxExtension>), - DeriveContainer(Vec<Lrc<SyntaxExtension>>), -} - /// Error type that denotes indeterminacy. pub struct Indeterminate; @@ -885,16 +863,29 @@ pub trait ResolverExpand { invoc: &Invocation, eager_expansion_root: ExpnId, force: bool, - ) -> Result<InvocationRes, Indeterminate>; + ) -> Result<Lrc<SyntaxExtension>, Indeterminate>; fn check_unused_macros(&mut self); /// Some parent node that is close enough to the given macro call. - fn lint_node_id(&mut self, expn_id: ExpnId) -> NodeId; + fn lint_node_id(&self, expn_id: ExpnId) -> NodeId; // Resolver interfaces for specific built-in macros. /// Does `#[derive(...)]` attribute with the given `ExpnId` have built-in `Copy` inside it? fn has_derive_copy(&self, expn_id: ExpnId) -> bool; + /// Resolve paths inside the `#[derive(...)]` attribute with the given `ExpnId`. + fn resolve_derives( + &mut self, + expn_id: ExpnId, + derives: Vec<ast::Path>, + force: bool, + ) -> Result<(), Indeterminate>; + /// Take resolutions for paths inside the `#[derive(...)]` attribute with the given `ExpnId` + /// back from resolver. + fn take_derive_resolutions( + &mut self, + expn_id: ExpnId, + ) -> Option<Vec<(Lrc<SyntaxExtension>, ast::Path)>>; /// Path resolution logic for `#[cfg_accessible(path)]`. fn cfg_accessible(&mut self, expn_id: ExpnId, path: &ast::Path) -> Result<bool, Indeterminate>; } diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs index 5fdb7fc5915..870b5c92d89 100644 --- a/compiler/rustc_expand/src/expand.rs +++ b/compiler/rustc_expand/src/expand.rs @@ -1,24 +1,26 @@ use crate::base::*; use crate::config::StripUnconfigured; use crate::configure; -use crate::hygiene::{ExpnData, ExpnKind, SyntaxContext}; +use crate::hygiene::SyntaxContext; use crate::mbe::macro_rules::annotate_err_with_kind; use crate::module::{parse_external_mod, push_directory, Directory, DirectoryOwnership}; use crate::placeholders::{placeholder, PlaceholderExpander}; -use crate::proc_macro::collect_derives; +use rustc_ast as ast; use rustc_ast::mut_visit::*; use rustc_ast::ptr::P; use rustc_ast::token; use rustc_ast::tokenstream::TokenStream; use rustc_ast::visit::{self, AssocCtxt, Visitor}; -use rustc_ast::{self as ast, AttrItem, AttrStyle, Block, LitKind, NodeId, PatKind, Path}; -use rustc_ast::{ItemKind, MacArgs, MacCallStmt, MacStmtStyle, StmtKind, Unsafe}; +use rustc_ast::{AttrItem, AttrStyle, Block, ItemKind, LitKind, MacArgs}; +use rustc_ast::{MacCallStmt, MacStmtStyle, MetaItemKind, NestedMetaItem}; +use rustc_ast::{NodeId, PatKind, Path, StmtKind, Unsafe}; use rustc_ast_pretty::pprust; use rustc_attr::{self as attr, is_builtin_attr, HasAttrs}; use rustc_data_structures::map_in_place::MapInPlace; use rustc_data_structures::stack::ensure_sufficient_stack; -use rustc_errors::{struct_span_err, Applicability, PResult}; +use rustc_data_structures::sync::Lrc; +use rustc_errors::{Applicability, PResult}; use rustc_feature::Features; use rustc_parse::parser::{AttemptLocalParseRecovery, ForceCollect, Parser}; use rustc_parse::validate_attr; @@ -302,20 +304,11 @@ pub enum InvocationKind { item: Annotatable, // Required for resolving derive helper attributes. derives: Vec<Path>, - // We temporarily report errors for attribute macros placed after derives - after_derive: bool, }, Derive { path: Path, item: Annotatable, }, - /// "Invocation" that contains all derives from an item, - /// broken into multiple `Derive` invocations when expanded. - /// FIXME: Find a way to remove it. - DeriveContainer { - derives: Vec<Path>, - item: Annotatable, - }, } impl InvocationKind { @@ -328,7 +321,6 @@ impl InvocationKind { match self { InvocationKind::Attr { item: Annotatable::StructField(field), .. } | InvocationKind::Derive { item: Annotatable::StructField(field), .. } - | InvocationKind::DeriveContainer { item: Annotatable::StructField(field), .. } if field.ident.is_none() => { Some(field.vis.clone()) @@ -344,7 +336,6 @@ impl Invocation { InvocationKind::Bang { span, .. } => *span, InvocationKind::Attr { attr, .. } => attr.span, InvocationKind::Derive { path, .. } => path.span, - InvocationKind::DeriveContainer { item, .. } => item.span(), } } } @@ -446,7 +437,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { let mut undetermined_invocations = Vec::new(); let (mut progress, mut force) = (false, !self.monotonic); loop { - let (invoc, res) = if let Some(invoc) = invocations.pop() { + let (invoc, ext) = if let Some(invoc) = invocations.pop() { invoc } else { self.resolve_imports(); @@ -464,8 +455,8 @@ impl<'a, 'b> MacroExpander<'a, 'b> { continue; }; - let res = match res { - Some(res) => res, + let ext = match ext { + Some(ext) => ext, None => { let eager_expansion_root = if self.monotonic { invoc.expansion_data.id @@ -477,7 +468,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { eager_expansion_root, force, ) { - Ok(res) => res, + Ok(ext) => ext, Err(Indeterminate) => { // Cannot resolve, will retry this invocation later. undetermined_invocations.push((invoc, None)); @@ -491,86 +482,78 @@ impl<'a, 'b> MacroExpander<'a, 'b> { self.cx.current_expansion = invoc.expansion_data.clone(); self.cx.force_mode = force; - // FIXME(jseyfried): Refactor out the following logic let fragment_kind = invoc.fragment_kind; - let (expanded_fragment, new_invocations) = match res { - InvocationRes::Single(ext) => match self.expand_invoc(invoc, &ext.kind) { - ExpandResult::Ready(fragment) => self.collect_invocations(fragment, &[]), - ExpandResult::Retry(invoc) => { - if force { - self.cx.span_bug( - invoc.span(), - "expansion entered force mode but is still stuck", - ); - } else { - // Cannot expand, will retry this invocation later. - undetermined_invocations - .push((invoc, Some(InvocationRes::Single(ext)))); - continue; - } - } - }, - InvocationRes::DeriveContainer(_exts) => { - // FIXME: Consider using the derive resolutions (`_exts`) immediately, - // instead of enqueuing the derives to be resolved again later. - let (derives, mut item) = match invoc.kind { - InvocationKind::DeriveContainer { derives, item } => (derives, item), - _ => unreachable!(), - }; - let (item, derive_placeholders) = if !item.derive_allowed() { - self.error_derive_forbidden_on_non_adt(&derives, &item); - item.visit_attrs(|attrs| attrs.retain(|a| !a.has_name(sym::derive))); - (item, Vec::new()) - } else { - let mut visitor = StripUnconfigured { - sess: self.cx.sess, - features: self.cx.ecfg.features, - modified: false, - }; - let mut item = visitor.fully_configure(item); - item.visit_attrs(|attrs| attrs.retain(|a| !a.has_name(sym::derive))); - if visitor.modified && !derives.is_empty() { - // Erase the tokens if cfg-stripping modified the item - // This will cause us to synthesize fake tokens - // when `nt_to_tokenstream` is called on this item. - match &mut item { - Annotatable::Item(item) => item.tokens = None, - Annotatable::Stmt(stmt) => { - if let StmtKind::Item(item) = &mut stmt.kind { - item.tokens = None - } else { - panic!("Unexpected stmt {:?}", stmt); - } - } - _ => panic!("Unexpected annotatable {:?}", item), + let (expanded_fragment, new_invocations) = match self.expand_invoc(invoc, &ext.kind) { + ExpandResult::Ready(fragment) => { + let derive_placeholders = self + .cx + .resolver + .take_derive_resolutions(expn_id) + .map(|derives| { + enum AnnotatableRef<'a> { + Item(&'a P<ast::Item>), + Stmt(&'a ast::Stmt), } - } + let item = match &fragment { + AstFragment::Items(items) => match &items[..] { + [item] => AnnotatableRef::Item(item), + _ => unreachable!(), + }, + AstFragment::Stmts(stmts) => match &stmts[..] { + [stmt] => AnnotatableRef::Stmt(stmt), + _ => unreachable!(), + }, + _ => unreachable!(), + }; - invocations.reserve(derives.len()); - let derive_placeholders = derives - .into_iter() - .map(|path| { - let expn_id = ExpnId::fresh(None); - invocations.push(( - Invocation { - kind: InvocationKind::Derive { path, item: item.clone() }, - fragment_kind, - expansion_data: ExpansionData { - id: expn_id, - ..self.cx.current_expansion.clone() + invocations.reserve(derives.len()); + derives + .into_iter() + .map(|(_exts, path)| { + // FIXME: Consider using the derive resolutions (`_exts`) + // instead of enqueuing the derives to be resolved again later. + let expn_id = ExpnId::fresh(None); + invocations.push(( + Invocation { + kind: InvocationKind::Derive { + path, + item: match item { + AnnotatableRef::Item(item) => { + Annotatable::Item(item.clone()) + } + AnnotatableRef::Stmt(stmt) => { + Annotatable::Stmt(P(stmt.clone())) + } + }, + }, + fragment_kind, + expansion_data: ExpansionData { + id: expn_id, + ..self.cx.current_expansion.clone() + }, }, - }, - None, - )); - NodeId::placeholder_from_expn_id(expn_id) - }) - .collect::<Vec<_>>(); - (item, derive_placeholders) - }; + None, + )); + NodeId::placeholder_from_expn_id(expn_id) + }) + .collect::<Vec<_>>() + }) + .unwrap_or_default(); - let fragment = fragment_kind.expect_from_annotatables(::std::iter::once(item)); self.collect_invocations(fragment, &derive_placeholders) } + ExpandResult::Retry(invoc) => { + if force { + self.cx.span_bug( + invoc.span(), + "expansion entered force mode but is still stuck", + ); + } else { + // Cannot expand, will retry this invocation later. + undetermined_invocations.push((invoc, Some(ext))); + continue; + } + } }; progress = true; @@ -596,29 +579,6 @@ impl<'a, 'b> MacroExpander<'a, 'b> { fragment_with_placeholders } - fn error_derive_forbidden_on_non_adt(&self, derives: &[Path], item: &Annotatable) { - let attr = self.cx.sess.find_by_name(item.attrs(), sym::derive); - let span = attr.map_or(item.span(), |attr| attr.span); - let mut err = struct_span_err!( - self.cx.sess, - span, - E0774, - "`derive` may only be applied to structs, enums and unions", - ); - if let Some(ast::Attribute { style: ast::AttrStyle::Inner, .. }) = attr { - let trait_list = derives.iter().map(|t| pprust::path_to_string(t)).collect::<Vec<_>>(); - let suggestion = format!("#[derive({})]", trait_list.join(", ")); - err.span_suggestion( - span, - "try an outer attribute", - suggestion, - // We don't 𝑘𝑛𝑜𝑤 that the following item is an ADT - Applicability::MaybeIncorrect, - ); - } - err.emit(); - } - fn resolve_imports(&mut self) { if self.monotonic { self.cx.resolver.resolve_imports(); @@ -633,7 +593,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { &mut self, mut fragment: AstFragment, extra_placeholders: &[NodeId], - ) -> (AstFragment, Vec<(Invocation, Option<InvocationRes>)>) { + ) -> (AstFragment, Vec<(Invocation, Option<Lrc<SyntaxExtension>>)>) { // Resolve `$crate`s in the fragment for pretty-printing. self.cx.resolver.resolve_dollar_crates(); @@ -733,7 +693,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { } _ => unreachable!(), }, - InvocationKind::Attr { attr, mut item, derives, after_derive } => match ext { + InvocationKind::Attr { attr, mut item, derives } => match ext { SyntaxExtensionKind::Attr(expander) => { self.gate_proc_macro_input(&item); self.gate_proc_macro_attr_item(span, &item); @@ -764,12 +724,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { ExpandResult::Retry(item) => { // Reassemble the original invocation for retrying. return ExpandResult::Retry(Invocation { - kind: InvocationKind::Attr { - attr, - item, - derives, - after_derive, - }, + kind: InvocationKind::Attr { attr, item, derives }, ..invoc }); } @@ -813,7 +768,6 @@ impl<'a, 'b> MacroExpander<'a, 'b> { } _ => unreachable!(), }, - InvocationKind::DeriveContainer { .. } => unreachable!(), }) } @@ -1011,29 +965,13 @@ pub fn ensure_complete_parse<'a>( struct InvocationCollector<'a, 'b> { cx: &'a mut ExtCtxt<'b>, cfg: StripUnconfigured<'a>, - invocations: Vec<(Invocation, Option<InvocationRes>)>, + invocations: Vec<(Invocation, Option<Lrc<SyntaxExtension>>)>, monotonic: bool, } impl<'a, 'b> InvocationCollector<'a, 'b> { fn collect(&mut self, fragment_kind: AstFragmentKind, kind: InvocationKind) -> AstFragment { - // Expansion data for all the collected invocations is set upon their resolution, - // with exception of the derive container case which is not resolved and can get - // its expansion data immediately. - let expn_data = match &kind { - InvocationKind::DeriveContainer { item, .. } => { - let mut expn_data = ExpnData::default( - ExpnKind::Macro(MacroKind::Attr, sym::derive), - item.span(), - self.cx.sess.parse_sess.edition, - None, - ); - expn_data.parent = self.cx.current_expansion.id; - Some(expn_data) - } - _ => None, - }; - let expn_id = ExpnId::fresh(expn_data); + let expn_id = ExpnId::fresh(None); let vis = kind.placeholder_visibility(); self.invocations.push(( Invocation { @@ -1061,64 +999,44 @@ impl<'a, 'b> InvocationCollector<'a, 'b> { fn collect_attr( &mut self, - (attr, derives, after_derive): (Option<ast::Attribute>, Vec<Path>, bool), + (attr, derives): (ast::Attribute, Vec<Path>), item: Annotatable, kind: AstFragmentKind, ) -> AstFragment { - self.collect( - kind, - match attr { - Some(attr) => InvocationKind::Attr { attr, item, derives, after_derive }, - None => InvocationKind::DeriveContainer { derives, item }, - }, - ) - } - - fn find_attr_invoc( - &self, - attrs: &mut Vec<ast::Attribute>, - after_derive: &mut bool, - ) -> Option<ast::Attribute> { - attrs - .iter() - .position(|a| { - if a.has_name(sym::derive) { - *after_derive = true; - } - !self.cx.sess.is_attr_known(a) && !is_builtin_attr(a) - }) - .map(|i| attrs.remove(i)) - } - - /// If `item` is an attr invocation, remove and return the macro attribute and derive traits. - fn take_first_attr( - &mut self, - item: &mut impl HasAttrs, - ) -> Option<(Option<ast::Attribute>, Vec<Path>, /* after_derive */ bool)> { - let (mut attr, mut traits, mut after_derive) = (None, Vec::new(), false); - - item.visit_attrs(|mut attrs| { - attr = self.find_attr_invoc(&mut attrs, &mut after_derive); - traits = collect_derives(&mut self.cx, &mut attrs); - }); - - if attr.is_some() || !traits.is_empty() { Some((attr, traits, after_derive)) } else { None } + self.collect(kind, InvocationKind::Attr { attr, item, derives }) } - /// Alternative to `take_first_attr()` that ignores `#[derive]` so invocations fallthrough - /// to the unused-attributes lint (making it an error on statements and expressions - /// is a breaking change) - fn take_first_attr_no_derive( - &mut self, - nonitem: &mut impl HasAttrs, - ) -> Option<(Option<ast::Attribute>, Vec<Path>, /* after_derive */ bool)> { - let (mut attr, mut after_derive) = (None, false); - - nonitem.visit_attrs(|mut attrs| { - attr = self.find_attr_invoc(&mut attrs, &mut after_derive); + /// If `item` is an attribute invocation, remove the attribute and return it together with + /// derives following it. We have to collect the derives in order to resolve legacy derive + /// helpers (helpers written before derives that introduce them). + fn take_first_attr(&mut self, item: &mut impl HasAttrs) -> Option<(ast::Attribute, Vec<Path>)> { + let mut attr = None; + + item.visit_attrs(|attrs| { + attr = attrs + .iter() + .position(|a| !self.cx.sess.is_attr_known(a) && !is_builtin_attr(a)) + .map(|attr_pos| { + let attr = attrs.remove(attr_pos); + let following_derives = attrs[attr_pos..] + .iter() + .filter(|a| a.has_name(sym::derive)) + .flat_map(|a| a.meta_item_list().unwrap_or_default()) + .filter_map(|nested_meta| match nested_meta { + NestedMetaItem::MetaItem(ast::MetaItem { + kind: MetaItemKind::Word, + path, + .. + }) => Some(path), + _ => None, + }) + .collect(); + + (attr, following_derives) + }) }); - attr.map(|attr| (Some(attr), Vec::new(), after_derive)) + attr } fn configure<T: HasAttrs>(&mut self, node: T) -> Option<T> { @@ -1132,17 +1050,6 @@ impl<'a, 'b> InvocationCollector<'a, 'b> { for attr in attrs.iter() { rustc_ast_passes::feature_gate::check_attribute(attr, self.cx.sess, features); validate_attr::check_meta(&self.cx.sess.parse_sess, attr); - - // macros are expanded before any lint passes so this warning has to be hardcoded - if attr.has_name(sym::derive) { - self.cx - .parse_sess() - .span_diagnostic - .struct_span_warn(attr.span, "`#[derive]` does nothing on macro invocations") - .note("this may become a hard error in a future release") - .emit(); - } - if attr.doc_str().is_some() { self.cx.sess.parse_sess.buffer_lint_with_diagnostic( &UNUSED_DOC_COMMENTS, @@ -1162,12 +1069,10 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> { visit_clobber(expr.deref_mut(), |mut expr| { self.cfg.configure_expr_kind(&mut expr.kind); - if let Some(attr) = self.take_first_attr_no_derive(&mut expr) { + if let Some(attr) = self.take_first_attr(&mut expr) { // Collect the invoc regardless of whether or not attributes are permitted here // expansion will eat the attribute so it won't error later. - if let Some(attr) = attr.0.as_ref() { - self.cfg.maybe_emit_expr_attr_err(attr) - } + self.cfg.maybe_emit_expr_attr_err(&attr.0); // AstFragmentKind::Expr requires the macro to emit an expression. return self @@ -1263,10 +1168,8 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> { expr.filter_map(|mut expr| { self.cfg.configure_expr_kind(&mut expr.kind); - if let Some(attr) = self.take_first_attr_no_derive(&mut expr) { - if let Some(attr) = attr.0.as_ref() { - self.cfg.maybe_emit_expr_attr_err(attr) - } + if let Some(attr) = self.take_first_attr(&mut expr) { + self.cfg.maybe_emit_expr_attr_err(&attr.0); return self .collect_attr(attr, Annotatable::Expr(P(expr)), AstFragmentKind::OptExpr) @@ -1308,15 +1211,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> { // we'll expand attributes on expressions separately if !stmt.is_expr() { - let attr = if stmt.is_item() { - self.take_first_attr(&mut stmt) - } else { - // Ignore derives on non-item statements for backwards compatibility. - // This will result in a unused attribute warning - self.take_first_attr_no_derive(&mut stmt) - }; - - if let Some(attr) = attr { + if let Some(attr) = self.take_first_attr(&mut stmt) { return self .collect_attr(attr, Annotatable::Stmt(P(stmt)), AstFragmentKind::Stmts) .make_stmts(); diff --git a/compiler/rustc_expand/src/proc_macro.rs b/compiler/rustc_expand/src/proc_macro.rs index 6779734cfc1..8cbaa7c945a 100644 --- a/compiler/rustc_expand/src/proc_macro.rs +++ b/compiler/rustc_expand/src/proc_macro.rs @@ -1,16 +1,14 @@ use crate::base::{self, *}; use crate::proc_macro_server; +use rustc_ast as ast; use rustc_ast::ptr::P; use rustc_ast::token; use rustc_ast::tokenstream::{CanSynthesizeMissingTokens, TokenStream, TokenTree}; -use rustc_ast::{self as ast, *}; use rustc_data_structures::sync::Lrc; -use rustc_errors::{struct_span_err, Applicability, ErrorReported}; -use rustc_lexer::is_ident; +use rustc_errors::ErrorReported; use rustc_parse::nt_to_tokenstream; use rustc_parse::parser::ForceCollect; -use rustc_span::symbol::sym; use rustc_span::{Span, DUMMY_SP}; const EXEC_STRATEGY: pm::bridge::server::SameThread = pm::bridge::server::SameThread; @@ -142,91 +140,3 @@ impl MultiItemModifier for ProcMacroDerive { ExpandResult::Ready(items) } } - -crate fn collect_derives(cx: &mut ExtCtxt<'_>, attrs: &mut Vec<ast::Attribute>) -> Vec<ast::Path> { - let mut result = Vec::new(); - attrs.retain(|attr| { - if !attr.has_name(sym::derive) { - return true; - } - - // 1) First let's ensure that it's a meta item. - let nmis = match attr.meta_item_list() { - None => { - cx.struct_span_err(attr.span, "malformed `derive` attribute input") - .span_suggestion( - attr.span, - "missing traits to be derived", - "#[derive(Trait1, Trait2, ...)]".to_owned(), - Applicability::HasPlaceholders, - ) - .emit(); - return false; - } - Some(x) => x, - }; - - let mut error_reported_filter_map = false; - let mut error_reported_map = false; - let traits = nmis - .into_iter() - // 2) Moreover, let's ensure we have a path and not `#[derive("foo")]`. - .filter_map(|nmi| match nmi { - NestedMetaItem::Literal(lit) => { - error_reported_filter_map = true; - let mut err = struct_span_err!( - cx.sess, - lit.span, - E0777, - "expected path to a trait, found literal", - ); - let token = lit.token.to_string(); - if token.starts_with('"') - && token.len() > 2 - && is_ident(&token[1..token.len() - 1]) - { - err.help(&format!("try using `#[derive({})]`", &token[1..token.len() - 1])); - } else { - err.help("for example, write `#[derive(Debug)]` for `Debug`"); - } - err.emit(); - None - } - NestedMetaItem::MetaItem(mi) => Some(mi), - }) - // 3) Finally, we only accept `#[derive($path_0, $path_1, ..)]` - // but not e.g. `#[derive($path_0 = "value", $path_1(abc))]`. - // In this case we can still at least determine that the user - // wanted this trait to be derived, so let's keep it. - .map(|mi| { - let mut traits_dont_accept = |title, action| { - error_reported_map = true; - let sp = mi.span.with_lo(mi.path.span.hi()); - cx.struct_span_err(sp, title) - .span_suggestion( - sp, - action, - String::new(), - Applicability::MachineApplicable, - ) - .emit(); - }; - match &mi.kind { - MetaItemKind::List(..) => traits_dont_accept( - "traits in `#[derive(...)]` don't accept arguments", - "remove the arguments", - ), - MetaItemKind::NameValue(..) => traits_dont_accept( - "traits in `#[derive(...)]` don't accept values", - "remove the value", - ), - MetaItemKind::Word => {} - } - mi.path - }); - - result.extend(traits); - !error_reported_filter_map && !error_reported_map - }); - result -} diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs index 818f6c70de0..2d0009c225c 100644 --- a/compiler/rustc_feature/src/active.rs +++ b/compiler/rustc_feature/src/active.rs @@ -631,6 +631,13 @@ declare_features! ( /// Allows `extern "C-cmse-nonsecure-call" fn()`. (active, abi_c_cmse_nonsecure_call, "1.51.0", Some(81391), None), + + /// Lessens the requirements for structs to implement `Unsize`. + (active, relaxed_struct_unsize, "1.51.0", Some(1), None), + + /// Allows macro attributes to observe output of `#[derive]`. + (active, macro_attributes_in_derive_output, "1.51.0", Some(81119), None), + // ------------------------------------------------------------------------- // feature-group-end: actual feature gates // ------------------------------------------------------------------------- diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index 3ed5320da73..ac50703b544 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -188,7 +188,6 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ungated!(reexport_test_harness_main, Normal, template!(NameValueStr: "name")), // Macros: - ungated!(derive, Normal, template!(List: "Trait1, Trait2, ...")), ungated!(automatically_derived, Normal, template!(Word)), // FIXME(#14407) ungated!(macro_use, Normal, template!(Word, List: "name1, name2, ...")), diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 6487b23a6a6..49d9e3b60b4 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -2015,6 +2015,7 @@ pub struct TypeBinding<'hir> { pub hir_id: HirId, #[stable_hasher(project(name))] pub ident: Ident, + pub gen_args: &'hir GenericArgs<'hir>, pub kind: TypeBindingKind<'hir>, pub span: Span, } @@ -2057,6 +2058,28 @@ pub enum PrimTy { } impl PrimTy { + /// All of the primitive types + pub const ALL: [Self; 17] = [ + // any changes here should also be reflected in `PrimTy::from_name` + Self::Int(IntTy::I8), + Self::Int(IntTy::I16), + Self::Int(IntTy::I32), + Self::Int(IntTy::I64), + Self::Int(IntTy::I128), + Self::Int(IntTy::Isize), + Self::Uint(UintTy::U8), + Self::Uint(UintTy::U16), + Self::Uint(UintTy::U32), + Self::Uint(UintTy::U64), + Self::Uint(UintTy::U128), + Self::Uint(UintTy::Usize), + Self::Float(FloatTy::F32), + Self::Float(FloatTy::F64), + Self::Bool, + Self::Char, + Self::Str, + ]; + pub fn name_str(self) -> &'static str { match self { PrimTy::Int(i) => i.name_str(), @@ -2078,6 +2101,33 @@ impl PrimTy { PrimTy::Char => sym::char, } } + + /// Returns the matching `PrimTy` for a `Symbol` such as "str" or "i32". + /// Returns `None` if no matching type is found. + pub fn from_name(name: Symbol) -> Option<Self> { + let ty = match name { + // any changes here should also be reflected in `PrimTy::ALL` + sym::i8 => Self::Int(IntTy::I8), + sym::i16 => Self::Int(IntTy::I16), + sym::i32 => Self::Int(IntTy::I32), + sym::i64 => Self::Int(IntTy::I64), + sym::i128 => Self::Int(IntTy::I128), + sym::isize => Self::Int(IntTy::Isize), + sym::u8 => Self::Uint(UintTy::U8), + sym::u16 => Self::Uint(UintTy::U16), + sym::u32 => Self::Uint(UintTy::U32), + sym::u64 => Self::Uint(UintTy::U64), + sym::u128 => Self::Uint(UintTy::U128), + sym::usize => Self::Uint(UintTy::Usize), + sym::f32 => Self::Float(FloatTy::F32), + sym::f64 => Self::Float(FloatTy::F64), + sym::bool => Self::Bool, + sym::char => Self::Char, + sym::str => Self::Str, + _ => return None, + }; + Some(ty) + } } #[derive(Debug, HashStable_Generic)] diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index 6c1bee2335a..f8b3f0d9b6e 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -781,6 +781,7 @@ pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>( ) { visitor.visit_id(type_binding.hir_id); visitor.visit_ident(type_binding.ident); + visitor.visit_generic_args(type_binding.span, type_binding.gen_args); match type_binding.kind { TypeBindingKind::Equality { ref ty } => { visitor.visit_ty(ty); diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index f1c2a6b7e6e..4595855309f 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -1840,6 +1840,7 @@ impl<'a> State<'a> { for binding in generic_args.bindings.iter() { start_or_comma(self); self.print_ident(binding.ident); + self.print_generic_args(binding.gen_args, false, false); self.s.space(); match generic_args.bindings[0].kind { hir::TypeBindingKind::Equality { ref ty } => { diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs index 0b501da7cd9..100824f4b94 100644 --- a/compiler/rustc_index/src/bit_set.rs +++ b/compiler/rustc_index/src/bit_set.rs @@ -707,6 +707,18 @@ impl<T: Idx> GrowableBitSet<T> { self.bit_set.insert(elem) } + /// Returns `true` if the set has changed. + #[inline] + pub fn remove(&mut self, elem: T) -> bool { + self.ensure(elem.index() + 1); + self.bit_set.remove(elem) + } + + #[inline] + pub fn is_empty(&self) -> bool { + self.bit_set.is_empty() + } + #[inline] pub fn contains(&self, elem: T) -> bool { let (word_index, mask) = word_index_and_mask(elem); diff --git a/compiler/rustc_index/src/bit_set/tests.rs b/compiler/rustc_index/src/bit_set/tests.rs index 6cc3e9427d1..c11b98e77aa 100644 --- a/compiler/rustc_index/src/bit_set/tests.rs +++ b/compiler/rustc_index/src/bit_set/tests.rs @@ -1,6 +1,7 @@ use super::*; extern crate test; +use std::hint::black_box; use test::Bencher; #[test] @@ -364,3 +365,36 @@ fn union_hybrid_sparse_full_small_domain(b: &mut Bencher) { sparse.union(&dense); }) } + +#[bench] +fn bench_insert(b: &mut Bencher) { + let mut bs = BitSet::new_filled(99999usize); + b.iter(|| { + black_box(bs.insert(black_box(100u32))); + }); +} + +#[bench] +fn bench_remove(b: &mut Bencher) { + let mut bs = BitSet::new_filled(99999usize); + b.iter(|| { + black_box(bs.remove(black_box(100u32))); + }); +} + +#[bench] +fn bench_iter(b: &mut Bencher) { + let bs = BitSet::new_filled(99999usize); + b.iter(|| { + bs.iter().map(|b: usize| black_box(b)).for_each(drop); + }); +} + +#[bench] +fn bench_intersect(b: &mut Bencher) { + let mut ba: BitSet<u32> = BitSet::new_filled(99999usize); + let bb = BitSet::new_filled(99999usize); + b.iter(|| { + ba.intersect(black_box(&bb)); + }); +} diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs index eaef4c7b54a..995034e81da 100644 --- a/compiler/rustc_index/src/lib.rs +++ b/compiler/rustc_index/src/lib.rs @@ -8,3 +8,7 @@ pub mod bit_set; pub mod vec; + +// FIXME(#56935): Work around ICEs during cross-compilation. +#[allow(unused)] +extern crate rustc_macros; diff --git a/compiler/rustc_infer/src/infer/lexical_region_resolve/README.md b/compiler/rustc_infer/src/infer/lexical_region_resolve/README.md index e0b2c0bffee..0a7da8c8063 100644 --- a/compiler/rustc_infer/src/infer/lexical_region_resolve/README.md +++ b/compiler/rustc_infer/src/infer/lexical_region_resolve/README.md @@ -1,4 +1,3 @@ - Lexical Region Resolution was removed in https://github.com/rust-lang/rust/pull/64790. Rust now uses Non-lexical lifetimes. For more info, please see the [borrowck diff --git a/compiler/rustc_lint/Cargo.toml b/compiler/rustc_lint/Cargo.toml index c56eb09b634..90badd3d573 100644 --- a/compiler/rustc_lint/Cargo.toml +++ b/compiler/rustc_lint/Cargo.toml @@ -19,5 +19,6 @@ rustc_data_structures = { path = "../rustc_data_structures" } rustc_feature = { path = "../rustc_feature" } rustc_index = { path = "../rustc_index" } rustc_session = { path = "../rustc_session" } +rustc_serialize = { path = "../rustc_serialize" } rustc_trait_selection = { path = "../rustc_trait_selection" } rustc_parse_format = { path = "../rustc_parse_format" } diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index 58a9064b919..b8db51f590d 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -21,7 +21,9 @@ use crate::passes::{EarlyLintPassObject, LateLintPassObject}; use rustc_ast as ast; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync; -use rustc_errors::{add_elided_lifetime_in_path_suggestion, struct_span_err, Applicability}; +use rustc_errors::{ + add_elided_lifetime_in_path_suggestion, struct_span_err, Applicability, SuggestionStyle, +}; use rustc_hir as hir; use rustc_hir::def::Res; use rustc_hir::def_id::{CrateNum, DefId}; @@ -32,7 +34,8 @@ use rustc_middle::middle::stability; use rustc_middle::ty::layout::{LayoutError, TyAndLayout}; use rustc_middle::ty::print::with_no_trimmed_paths; use rustc_middle::ty::{self, print::Printer, subst::GenericArg, Ty, TyCtxt}; -use rustc_session::lint::BuiltinLintDiagnostics; +use rustc_serialize::json::Json; +use rustc_session::lint::{BuiltinLintDiagnostics, ExternDepSpec}; use rustc_session::lint::{FutureIncompatibleInfo, Level, Lint, LintBuffer, LintId}; use rustc_session::Session; use rustc_session::SessionLintStore; @@ -636,6 +639,33 @@ pub trait LintContext: Sized { db.span_label(span, "ABI should be specified here"); db.help(&format!("the default ABI is {}", default_abi.name())); } + BuiltinLintDiagnostics::LegacyDeriveHelpers(span) => { + db.span_label(span, "the attribute is introduced here"); + } + BuiltinLintDiagnostics::ExternDepSpec(krate, loc) => { + let json = match loc { + ExternDepSpec::Json(json) => { + db.help(&format!("remove unnecessary dependency `{}`", krate)); + json + } + ExternDepSpec::Raw(raw) => { + db.help(&format!("remove unnecessary dependency `{}` at `{}`", krate, raw)); + db.span_suggestion_with_style( + DUMMY_SP, + "raw extern location", + raw.clone(), + Applicability::Unspecified, + SuggestionStyle::CompletelyHidden, + ); + Json::String(raw) + } + }; + db.tool_only_suggestion_with_metadata( + "json extern location", + Applicability::Unspecified, + json + ); + } } // Rewrap `db`, and pass control to the user. decorate(LintDiagnosticBuilder::new(db)); diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs index da62ad3a6b1..f0a5ea150b7 100644 --- a/compiler/rustc_lint_defs/src/builtin.rs +++ b/compiler/rustc_lint_defs/src/builtin.rs @@ -1,12 +1,11 @@ // ignore-tidy-filelength + //! Some lints that are built in to the compiler. //! //! These are the built-in lints that are emitted direct in the main //! compiler code, rather than using their own custom pass. Those //! lints are all available in `rustc_lint::builtin`. -// ignore-tidy-filelength - use crate::{declare_lint, declare_lint_pass}; use rustc_span::edition::Edition; use rustc_span::symbol::sym; @@ -2922,6 +2921,52 @@ declare_lint! { }; } +declare_lint! { + /// The `legacy_derive_helpers` lint detects derive helper attributes + /// that are used before they are introduced. + /// + /// ### Example + /// + /// ```rust,ignore (needs extern crate) + /// #[serde(rename_all = "camelCase")] + /// #[derive(Deserialize)] + /// struct S { /* fields */ } + /// ``` + /// + /// produces: + /// + /// ```text + /// warning: derive helper attribute is used before it is introduced + /// --> $DIR/legacy-derive-helpers.rs:1:3 + /// | + /// 1 | #[serde(rename_all = "camelCase")] + /// | ^^^^^ + /// ... + /// 2 | #[derive(Deserialize)] + /// | ----------- the attribute is introduced here + /// ``` + /// + /// ### Explanation + /// + /// Attributes like this work for historical reasons, but attribute expansion works in + /// left-to-right order in general, so, to resolve `#[serde]`, compiler has to try to "look + /// into the future" at not yet expanded part of the item , but such attempts are not always + /// reliable. + /// + /// To fix the warning place the helper attribute after its corresponding derive. + /// ```rust,ignore (needs extern crate) + /// #[derive(Deserialize)] + /// #[serde(rename_all = "camelCase")] + /// struct S { /* fields */ } + /// ``` + pub LEGACY_DERIVE_HELPERS, + Warn, + "detects derive helper attributes that are used before they are introduced", + @future_incompatible = FutureIncompatibleInfo { + reference: "issue #79202 <https://github.com/rust-lang/rust/issues/79202>", + }; +} + declare_lint_pass! { /// Does nothing as a lint pass, but registers some `Lint`s /// that are used by other parts of the compiler. @@ -3012,6 +3057,7 @@ declare_lint_pass! { MISSING_ABI, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS, DISJOINT_CAPTURE_DROP_REORDER, + LEGACY_DERIVE_HELPERS, ] } diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs index 9d60a51a0af..4c7d3f6c8c0 100644 --- a/compiler/rustc_lint_defs/src/lib.rs +++ b/compiler/rustc_lint_defs/src/lib.rs @@ -4,6 +4,7 @@ extern crate rustc_macros; pub use self::Level::*; use rustc_ast::node_id::{NodeId, NodeMap}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; +use rustc_serialize::json::Json; use rustc_span::edition::Edition; use rustc_span::{sym, symbol::Ident, MultiSpan, Span, Symbol}; use rustc_target::spec::abi::Abi; @@ -239,6 +240,13 @@ impl<HCX> ToStableHashKey<HCX> for LintId { } } +// Duplicated from rustc_session::config::ExternDepSpec to avoid cyclic dependency +#[derive(PartialEq)] +pub enum ExternDepSpec { + Json(Json), + Raw(String), +} + // This could be a closure, but then implementing derive trait // becomes hacky (and it gets allocated). #[derive(PartialEq)] @@ -256,6 +264,8 @@ pub enum BuiltinLintDiagnostics { MissingAbi(Span, Abi), UnusedDocComment(Span), PatternsInFnsWithoutBody(Span, Ident), + LegacyDeriveHelpers(Span), + ExternDepSpec(String, ExternDepSpec), } /// Lints that are buffered up early on in the `Session` before the diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs index e3fbd1a2b29..63c6f369eb6 100644 --- a/compiler/rustc_metadata/src/creader.rs +++ b/compiler/rustc_metadata/src/creader.rs @@ -16,8 +16,9 @@ use rustc_index::vec::IndexVec; use rustc_middle::middle::cstore::{CrateDepKind, CrateSource, ExternCrate}; use rustc_middle::middle::cstore::{ExternCrateSource, MetadataLoaderDyn}; use rustc_middle::ty::TyCtxt; +use rustc_serialize::json::ToJson; use rustc_session::config::{self, CrateType, ExternLocation}; -use rustc_session::lint; +use rustc_session::lint::{self, BuiltinLintDiagnostics, ExternDepSpec}; use rustc_session::output::validate_crate_name; use rustc_session::search_paths::PathKind; use rustc_session::{CrateDisambiguator, Session}; @@ -27,6 +28,7 @@ use rustc_span::{Span, DUMMY_SP}; use rustc_target::spec::{PanicStrategy, TargetTriple}; use proc_macro::bridge::client::ProcMacro; +use std::collections::BTreeMap; use std::path::Path; use std::{cmp, env}; use tracing::{debug, info}; @@ -871,8 +873,25 @@ impl<'a> CrateLoader<'a> { // Don't worry about pathless `--extern foo` sysroot references continue; } - if !self.used_extern_options.contains(&Symbol::intern(name)) { - self.sess.parse_sess.buffer_lint( + if self.used_extern_options.contains(&Symbol::intern(name)) { + continue; + } + + // Got a real unused --extern + let diag = match self.sess.opts.extern_dep_specs.get(name) { + Some(loc) => BuiltinLintDiagnostics::ExternDepSpec(name.clone(), loc.into()), + None => { + // If we don't have a specific location, provide a json encoding of the `--extern` + // option. + let meta: BTreeMap<String, String> = + std::iter::once(("name".to_string(), name.to_string())).collect(); + BuiltinLintDiagnostics::ExternDepSpec( + name.clone(), + ExternDepSpec::Json(meta.to_json()), + ) + } + }; + self.sess.parse_sess.buffer_lint_with_diagnostic( lint::builtin::UNUSED_CRATE_DEPENDENCIES, span, ast::CRATE_NODE_ID, @@ -881,8 +900,8 @@ impl<'a> CrateLoader<'a> { name, self.local_crate_name, name), + diag, ); - } } } diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 3961adaceca..dd6a6fe6248 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -2,15 +2,15 @@ use crate::rmeta::table::{FixedSizeEncoding, TableBuilder}; use crate::rmeta::*; use rustc_data_structures::fingerprint::{Fingerprint, FingerprintEncoder}; -use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet}; +use rustc_data_structures::fx::{FxHashMap, FxIndexSet}; use rustc_data_structures::stable_hasher::StableHasher; -use rustc_data_structures::sync::{join, Lrc}; +use rustc_data_structures::sync::{join, par_iter, Lrc, ParallelIterator}; use rustc_hir as hir; use rustc_hir::def::{CtorOf, DefKind}; use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; use rustc_hir::definitions::DefPathData; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; -use rustc_hir::itemlikevisit::{ItemLikeVisitor, ParItemLikeVisitor}; +use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_hir::lang_items; use rustc_hir::{AnonConst, GenericParamKind}; use rustc_index::bit_set::GrowableBitSet; @@ -65,11 +65,6 @@ pub(super) struct EncodeContext<'a, 'tcx> { required_source_files: Option<GrowableBitSet<usize>>, is_proc_macro: bool, hygiene_ctxt: &'a HygieneEncodeContext, - - // Determines if MIR used for code generation will be included in the crate - // metadata. When emitting only metadata (e.g., cargo check), we can avoid - // generating optimized MIR altogether. - emit_codegen_mir: bool, } /// If the current crate is a proc-macro, returns early with `Lazy:empty()`. @@ -580,6 +575,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode the items. i = self.position(); self.encode_def_ids(); + self.encode_mir(); self.encode_info_for_items(); let item_bytes = self.position() - i; @@ -785,6 +781,53 @@ fn should_encode_stability(def_kind: DefKind) -> bool { } } +/// Whether we should encode MIR. +/// +/// Computing, optimizing and encoding the MIR is a relatively expensive operation. +/// We want to avoid this work when not required. Therefore: +/// - we only compute `mir_for_ctfe` on items with const-eval semantics; +/// - we skip `optimized_mir` for check runs. +/// +/// Return a pair, resp. for CTFE and for LLVM. +fn should_encode_mir(tcx: TyCtxt<'_>, def_id: LocalDefId) -> (bool, bool) { + match tcx.def_kind(def_id) { + // Constructors + DefKind::Ctor(_, _) => { + let mir_opt_base = tcx.sess.opts.output_types.should_codegen() + || tcx.sess.opts.debugging_opts.always_encode_mir; + (true, mir_opt_base) + } + // Constants + DefKind::AnonConst | DefKind::AssocConst | DefKind::Static | DefKind::Const => { + (true, false) + } + // Full-fledged functions + DefKind::AssocFn | DefKind::Fn => { + let generics = tcx.generics_of(def_id); + let needs_inline = (generics.requires_monomorphization(tcx) + || tcx.codegen_fn_attrs(def_id).requests_inline()) + && tcx.sess.opts.output_types.should_codegen(); + // Only check the presence of the `const` modifier. + let is_const_fn = tcx.is_const_fn_raw(def_id.to_def_id()); + let always_encode_mir = tcx.sess.opts.debugging_opts.always_encode_mir; + (is_const_fn, needs_inline || always_encode_mir) + } + // Closures can't be const fn. + DefKind::Closure => { + let generics = tcx.generics_of(def_id); + let needs_inline = (generics.requires_monomorphization(tcx) + || tcx.codegen_fn_attrs(def_id).requests_inline()) + && tcx.sess.opts.output_types.should_codegen(); + let always_encode_mir = tcx.sess.opts.debugging_opts.always_encode_mir; + (false, needs_inline || always_encode_mir) + } + // Generators require optimized MIR to compute layout. + DefKind::Generator => (false, true), + // The others don't have MIR. + _ => (false, false), + } +} + impl EncodeContext<'a, 'tcx> { fn encode_def_ids(&mut self) { if self.is_proc_macro { @@ -882,11 +925,6 @@ impl EncodeContext<'a, 'tcx> { self.encode_generics(def_id); self.encode_explicit_predicates(def_id); self.encode_inferred_outlives(def_id); - let opt_mir = tcx.sess.opts.debugging_opts.always_encode_mir || self.emit_codegen_mir; - if opt_mir { - self.encode_optimized_mir(def_id.expect_local()); - } - self.encode_mir_for_ctfe(def_id.expect_local()); } fn encode_info_for_mod(&mut self, id: hir::HirId, md: &hir::Mod<'_>) { @@ -972,11 +1010,6 @@ impl EncodeContext<'a, 'tcx> { self.encode_generics(def_id); self.encode_explicit_predicates(def_id); self.encode_inferred_outlives(def_id); - let opt_mir = tcx.sess.opts.debugging_opts.always_encode_mir || self.emit_codegen_mir; - if opt_mir { - self.encode_optimized_mir(def_id.expect_local()); - } - self.encode_mir_for_ctfe(def_id.expect_local()); } fn encode_generics(&mut self, def_id: DefId) { @@ -1082,34 +1115,6 @@ impl EncodeContext<'a, 'tcx> { self.encode_generics(def_id); self.encode_explicit_predicates(def_id); self.encode_inferred_outlives(def_id); - - // This should be kept in sync with `PrefetchVisitor.visit_trait_item`. - match trait_item.kind { - ty::AssocKind::Type => {} - ty::AssocKind::Const => { - if self.tcx.mir_keys(LOCAL_CRATE).contains(&def_id.expect_local()) { - self.encode_mir_for_ctfe(def_id.expect_local()); - self.encode_promoted_mir(def_id.expect_local()); - } - } - ty::AssocKind::Fn => { - let opt_mir = - tcx.sess.opts.debugging_opts.always_encode_mir || self.emit_codegen_mir; - if opt_mir { - if self.tcx.mir_keys(LOCAL_CRATE).contains(&def_id.expect_local()) { - self.encode_optimized_mir(def_id.expect_local()); - self.encode_promoted_mir(def_id.expect_local()); - } - } - } - } - } - - fn should_encode_fn_opt_mir(&self, def_id: DefId) -> bool { - self.tcx.sess.opts.debugging_opts.always_encode_mir - || (self.emit_codegen_mir - && (self.tcx.generics_of(def_id).requires_monomorphization(self.tcx) - || self.tcx.codegen_fn_attrs(def_id).requests_inline())) } fn encode_info_for_impl_item(&mut self, def_id: DefId) { @@ -1171,27 +1176,6 @@ impl EncodeContext<'a, 'tcx> { self.encode_generics(def_id); self.encode_explicit_predicates(def_id); self.encode_inferred_outlives(def_id); - - // The following part should be kept in sync with `PrefetchVisitor.visit_impl_item`. - - let (mir, mir_const) = match ast_item.kind { - hir::ImplItemKind::Const(..) => (false, true), - hir::ImplItemKind::Fn(ref sig, _) => { - let opt_mir = self.should_encode_fn_opt_mir(def_id); - let is_const_fn = sig.header.constness == hir::Constness::Const; - (opt_mir, is_const_fn) - } - hir::ImplItemKind::TyAlias(..) => (false, false), - }; - if mir { - self.encode_optimized_mir(def_id.expect_local()); - } - if mir || mir_const { - self.encode_promoted_mir(def_id.expect_local()); - } - if mir_const { - self.encode_mir_for_ctfe(def_id.expect_local()); - } } fn encode_fn_param_names_for_body(&mut self, body_id: hir::BodyId) -> Lazy<[Ident]> { @@ -1202,34 +1186,48 @@ impl EncodeContext<'a, 'tcx> { self.lazy(param_names.iter()) } - fn encode_mir_for_ctfe(&mut self, def_id: LocalDefId) { - debug!("EntryBuilder::encode_mir_for_ctfe({:?})", def_id); - record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- self.tcx.mir_for_ctfe(def_id)); - - let unused = self.tcx.unused_generic_params(def_id); - if !unused.is_empty() { - record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused); + fn encode_mir(&mut self) { + if self.is_proc_macro { + return; } - let abstract_const = self.tcx.mir_abstract_const(def_id); - if let Ok(Some(abstract_const)) = abstract_const { - record!(self.tables.mir_abstract_consts[def_id.to_def_id()] <- abstract_const); - } - } + let mut keys_and_jobs = self + .tcx + .mir_keys(LOCAL_CRATE) + .iter() + .filter_map(|&def_id| { + let (encode_const, encode_opt) = should_encode_mir(self.tcx, def_id); + if encode_const || encode_opt { + Some((def_id, encode_const, encode_opt)) + } else { + None + } + }) + .collect::<Vec<_>>(); + // Sort everything to ensure a stable order for diagnotics. + keys_and_jobs.sort_by_key(|&(def_id, _, _)| def_id); + for (def_id, encode_const, encode_opt) in keys_and_jobs.into_iter() { + debug_assert!(encode_const || encode_opt); - fn encode_optimized_mir(&mut self, def_id: LocalDefId) { - debug!("EntryBuilder::encode_optimized_mir({:?})", def_id); - record!(self.tables.mir[def_id.to_def_id()] <- self.tcx.optimized_mir(def_id)); + debug!("EntryBuilder::encode_mir({:?})", def_id); + if encode_opt { + record!(self.tables.mir[def_id.to_def_id()] <- self.tcx.optimized_mir(def_id)); + } + if encode_const { + record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- self.tcx.mir_for_ctfe(def_id)); - let unused = self.tcx.unused_generic_params(def_id); - if !unused.is_empty() { - record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused); - } - } + let abstract_const = self.tcx.mir_abstract_const(def_id); + if let Ok(Some(abstract_const)) = abstract_const { + record!(self.tables.mir_abstract_consts[def_id.to_def_id()] <- abstract_const); + } + } + record!(self.tables.promoted_mir[def_id.to_def_id()] <- self.tcx.promoted_mir(def_id)); - fn encode_promoted_mir(&mut self, def_id: LocalDefId) { - debug!("EncodeContext::encode_promoted_mir({:?})", def_id); - record!(self.tables.promoted_mir[def_id.to_def_id()] <- self.tcx.promoted_mir(def_id)); + let unused = self.tcx.unused_generic_params(def_id); + if !unused.is_empty() { + record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused); + } + } } // Encodes the inherent implementations of a structure, enumeration, or trait. @@ -1487,28 +1485,6 @@ impl EncodeContext<'a, 'tcx> { } _ => {} } - - // The following part should be kept in sync with `PrefetchVisitor.visit_item`. - - let (mir, const_mir) = match item.kind { - hir::ItemKind::Static(..) | hir::ItemKind::Const(..) => (false, true), - hir::ItemKind::Fn(ref sig, ..) => { - let opt_mir = self.should_encode_fn_opt_mir(def_id); - let is_const_fn = sig.header.constness == hir::Constness::Const; - // We don't need the optimized MIR for const fns. - (opt_mir, is_const_fn) - } - _ => (false, false), - }; - if mir { - self.encode_optimized_mir(def_id.expect_local()); - } - if mir || const_mir { - self.encode_promoted_mir(def_id.expect_local()); - } - if const_mir { - self.encode_mir_for_ctfe(def_id.expect_local()); - } } /// Serialize the text of exported macros @@ -1550,14 +1526,6 @@ impl EncodeContext<'a, 'tcx> { record!(self.tables.fn_sig[def_id] <- substs.as_closure().sig()); } self.encode_generics(def_id.to_def_id()); - let opt_mir = // FIXME: Optimized MIR is necessary to determine the layout of generators. - matches!(ty.kind(), ty::Generator(..)) - || self.tcx.sess.opts.debugging_opts.always_encode_mir - || self.emit_codegen_mir; - if opt_mir { - self.encode_optimized_mir(def_id); - self.encode_promoted_mir(def_id); - } } fn encode_info_for_anon_const(&mut self, def_id: LocalDefId) { @@ -1572,8 +1540,6 @@ impl EncodeContext<'a, 'tcx> { self.encode_generics(def_id.to_def_id()); self.encode_explicit_predicates(def_id.to_def_id()); self.encode_inferred_outlives(def_id.to_def_id()); - self.encode_mir_for_ctfe(def_id); - self.encode_promoted_mir(def_id); } fn encode_native_libraries(&mut self) -> Lazy<[NativeLib]> { @@ -2038,90 +2004,25 @@ impl<'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'tcx> { /// Used to prefetch queries which will be needed later by metadata encoding. /// Only a subset of the queries are actually prefetched to keep this code smaller. -struct PrefetchVisitor<'tcx> { - tcx: TyCtxt<'tcx>, - mir_keys: &'tcx FxHashSet<LocalDefId>, -} - -impl<'tcx> PrefetchVisitor<'tcx> { - fn prefetch_ctfe_mir(&self, def_id: LocalDefId) { - if self.mir_keys.contains(&def_id) { - self.tcx.ensure().mir_for_ctfe(def_id); - self.tcx.ensure().promoted_mir(def_id); - } - } - fn prefetch_mir(&self, def_id: LocalDefId) { - if self.mir_keys.contains(&def_id) { - self.tcx.ensure().optimized_mir(def_id); - self.tcx.ensure().promoted_mir(def_id); - } +fn prefetch_mir(tcx: TyCtxt<'_>) { + if !tcx.sess.opts.output_types.should_codegen() { + // We won't emit MIR, so don't prefetch it. + return; } -} -impl<'tcx, 'v> ParItemLikeVisitor<'v> for PrefetchVisitor<'tcx> { - fn visit_item(&self, item: &hir::Item<'_>) { - // This should be kept in sync with `encode_info_for_item`. - let tcx = self.tcx; - match item.kind { - hir::ItemKind::Static(..) | hir::ItemKind::Const(..) => { - self.prefetch_ctfe_mir(tcx.hir().local_def_id(item.hir_id)) - } - hir::ItemKind::Fn(ref sig, ..) => { - let def_id = tcx.hir().local_def_id(item.hir_id); - let opt_mir = tcx.generics_of(def_id.to_def_id()).requires_monomorphization(tcx) - || tcx.codegen_fn_attrs(def_id.to_def_id()).requests_inline(); - if opt_mir { - self.prefetch_mir(def_id) - } - if sig.header.constness == hir::Constness::Const { - self.prefetch_ctfe_mir(def_id); - } - } - _ => (), - } - } + par_iter(tcx.mir_keys(LOCAL_CRATE)).for_each(|&def_id| { + let (encode_const, encode_opt) = should_encode_mir(tcx, def_id); - fn visit_trait_item(&self, trait_item: &'v hir::TraitItem<'v>) { - // This should be kept in sync with `encode_info_for_trait_item`. - let def_id = self.tcx.hir().local_def_id(trait_item.hir_id); - match trait_item.kind { - hir::TraitItemKind::Type(..) => {} - hir::TraitItemKind::Const(..) => { - self.prefetch_ctfe_mir(def_id); - } - hir::TraitItemKind::Fn(..) => { - self.prefetch_mir(def_id); - } + if encode_const { + tcx.ensure().mir_for_ctfe(def_id); } - } - - fn visit_impl_item(&self, impl_item: &'v hir::ImplItem<'v>) { - // This should be kept in sync with `encode_info_for_impl_item`. - let tcx = self.tcx; - match impl_item.kind { - hir::ImplItemKind::Const(..) => { - self.prefetch_ctfe_mir(tcx.hir().local_def_id(impl_item.hir_id)) - } - hir::ImplItemKind::Fn(ref sig, _) => { - let def_id = tcx.hir().local_def_id(impl_item.hir_id); - let opt_mir = tcx.generics_of(def_id.to_def_id()).requires_monomorphization(tcx) - || tcx.codegen_fn_attrs(def_id.to_def_id()).requests_inline(); - let is_const_fn = sig.header.constness == hir::Constness::Const; - if opt_mir { - self.prefetch_mir(def_id) - } - if is_const_fn { - self.prefetch_ctfe_mir(def_id); - } - } - hir::ImplItemKind::TyAlias(..) => (), + if encode_opt { + tcx.ensure().optimized_mir(def_id); } - } - - fn visit_foreign_item(&self, _foreign_item: &'v hir::ForeignItem<'v>) { - // This should be kept in sync with `encode_info_for_foreign_item`. - // Foreign items contain no MIR. - } + if encode_opt || encode_const { + tcx.ensure().promoted_mir(def_id); + } + }) } // NOTE(eddyb) The following comment was preserved for posterity, even @@ -2161,19 +2062,7 @@ pub(super) fn encode_metadata(tcx: TyCtxt<'_>) -> EncodedMetadata { // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. - join( - || { - if !tcx.sess.opts.output_types.should_codegen() { - // We won't emit MIR, so don't prefetch it. - return; - } - tcx.hir().krate().par_visit_all_item_likes(&PrefetchVisitor { - tcx, - mir_keys: tcx.mir_keys(LOCAL_CRATE), - }); - }, - || tcx.exported_symbols(LOCAL_CRATE), - ); + join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); }, ) .0 @@ -2206,7 +2095,6 @@ fn encode_metadata_impl(tcx: TyCtxt<'_>) -> EncodedMetadata { required_source_files, is_proc_macro: tcx.sess.crate_types().contains(&CrateType::ProcMacro), hygiene_ctxt: &hygiene_ctxt, - emit_codegen_mir: tcx.sess.opts.output_types.should_codegen(), }; // Encode the rustc version string in a predictable location. diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs index 596e4f67174..0b592ca4710 100644 --- a/compiler/rustc_middle/src/ty/layout.rs +++ b/compiler/rustc_middle/src/ty/layout.rs @@ -188,6 +188,13 @@ pub const FAT_PTR_ADDR: usize = 0; /// - For a slice, this is the length. pub const FAT_PTR_EXTRA: usize = 1; +/// The maximum supported number of lanes in a SIMD vector. +/// +/// This value is selected based on backend support: +/// * LLVM does not appear to have a vector width limit. +/// * Cranelift stores the base-2 log of the lane count in a 4 bit integer. +pub const MAX_SIMD_LANES: u64 = 1 << 0xF; + #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable)] pub enum LayoutError<'tcx> { Unknown(Ty<'tcx>), @@ -717,10 +724,22 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> { }; // SIMD vectors of zero length are not supported. + // Additionally, lengths are capped at 2^16 as a fixed maximum backends must + // support. // // Can't be caught in typeck if the array length is generic. if e_len == 0 { tcx.sess.fatal(&format!("monomorphising SIMD type `{}` of zero length", ty)); + } else if !e_len.is_power_of_two() { + tcx.sess.fatal(&format!( + "monomorphising SIMD type `{}` of non-power-of-two length", + ty + )); + } else if e_len > MAX_SIMD_LANES { + tcx.sess.fatal(&format!( + "monomorphising SIMD type `{}` of length greater than {}", + ty, MAX_SIMD_LANES, + )); } // Compute the ABI of the element type: diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index 4937fdd7314..a8d9995bd0b 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -2143,6 +2143,7 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N match child.res { def::Res::Def(DefKind::AssocTy, _) => {} + def::Res::Def(DefKind::TyAlias, _) => {} def::Res::Def(defkind, def_id) => { if let Some(ns) = defkind.ns() { collect_fn(&child.ident, ns, def_id); diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs index 6b4f08d9f93..c1fa84dcb25 100644 --- a/compiler/rustc_middle/src/ty/sty.rs +++ b/compiler/rustc_middle/src/ty/sty.rs @@ -1132,8 +1132,16 @@ impl<'tcx> ProjectionTy<'tcx> { /// For example, if this is a projection of `<T as Iterator>::Item`, /// then this function would return a `T: Iterator` trait reference. pub fn trait_ref(&self, tcx: TyCtxt<'tcx>) -> ty::TraitRef<'tcx> { + // FIXME: This method probably shouldn't exist at all, since it's not + // clear what this method really intends to do. Be careful when + // using this method since the resulting TraitRef additionally + // contains the substs for the assoc_item, which strictly speaking + // is not correct let def_id = tcx.associated_item(self.item_def_id).container.id(); - ty::TraitRef { def_id, substs: self.substs.truncate_to(tcx, tcx.generics_of(def_id)) } + // Include substitutions for generic arguments of associated types + let assoc_item = tcx.associated_item(self.item_def_id); + let substs_assoc_item = self.substs.truncate_to(tcx, tcx.generics_of(assoc_item.def_id)); + ty::TraitRef { def_id, substs: substs_assoc_item } } pub fn self_ty(&self) -> Ty<'tcx> { diff --git a/compiler/rustc_mir/src/transform/inline.rs b/compiler/rustc_mir/src/transform/inline.rs index dd9a514466d..1635a95f46e 100644 --- a/compiler/rustc_mir/src/transform/inline.rs +++ b/compiler/rustc_mir/src/transform/inline.rs @@ -281,6 +281,11 @@ impl Inliner<'tcx> { return false; } + if self.codegen_fn_attrs.instruction_set != codegen_fn_attrs.instruction_set { + debug!("`callee has incompatible instruction set - not inlining"); + return false; + } + let hinted = match codegen_fn_attrs.inline { // Just treat inline(always) as a hint for now, // there are cases that prevent inlining that we diff --git a/compiler/rustc_mir_build/src/build/block.rs b/compiler/rustc_mir_build/src/build/block.rs index 82f38ac0e76..d5f72e6f22d 100644 --- a/compiler/rustc_mir_build/src/build/block.rs +++ b/compiler/rustc_mir_build/src/build/block.rs @@ -3,7 +3,6 @@ use crate::build::ForGuard::OutsideGuard; use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; use crate::thir::*; use rustc_hir as hir; -use rustc_middle::middle::region; use rustc_middle::mir::*; use rustc_session::lint::builtin::UNSAFE_OP_IN_UNSAFE_FN; use rustc_session::lint::Level; @@ -13,7 +12,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { crate fn ast_block( &mut self, destination: Place<'tcx>, - scope: Option<region::Scope>, block: BasicBlock, ast_block: &'tcx hir::Block<'tcx>, source_info: SourceInfo, @@ -30,10 +28,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { self.in_opt_scope(opt_destruction_scope.map(|de| (de, source_info)), move |this| { this.in_scope((region_scope, source_info), LintLevel::Inherited, move |this| { if targeted_by_break { - this.in_breakable_scope(None, destination, scope, span, |this| { + this.in_breakable_scope(None, destination, span, |this| { Some(this.ast_block_stmts( destination, - scope, block, span, stmts, @@ -42,7 +39,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { )) }) } else { - this.ast_block_stmts(destination, scope, block, span, stmts, expr, safety_mode) + this.ast_block_stmts(destination, block, span, stmts, expr, safety_mode) } }) }) @@ -51,7 +48,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { fn ast_block_stmts( &mut self, destination: Place<'tcx>, - scope: Option<region::Scope>, mut block: BasicBlock, span: Span, stmts: Vec<StmtRef<'tcx>>, @@ -186,7 +182,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { }; this.block_context.push(BlockFrame::TailExpr { tail_result_is_ignored, span }); - unpack!(block = this.into(destination, scope, block, expr)); + unpack!(block = this.into(destination, block, expr)); let popped = this.block_context.pop(); assert!(popped.map_or(false, |bf| bf.is_tail_expr())); diff --git a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs index c95fc969797..e602f4dd71d 100644 --- a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs +++ b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs @@ -12,8 +12,6 @@ use rustc_middle::mir::*; use rustc_middle::ty::{self, Ty, UpvarSubsts}; use rustc_span::Span; -use std::slice; - impl<'a, 'tcx> Builder<'a, 'tcx> { /// Returns an rvalue suitable for use until the end of the current /// scope expression. @@ -115,19 +113,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let box_ = Rvalue::NullaryOp(NullOp::Box, value.ty); this.cfg.push_assign(block, source_info, Place::from(result), box_); - // Initialize the box contents. No scope is needed since the - // `Box` is already scheduled to be dropped. + // initialize the box contents: unpack!( - block = this.into( - this.hir.tcx().mk_place_deref(Place::from(result)), - None, - block, - value, - ) + block = + this.into(this.hir.tcx().mk_place_deref(Place::from(result)), block, value) ); - let result_operand = Operand::Move(Place::from(result)); - this.record_operands_moved(slice::from_ref(&result_operand)); - block.and(Rvalue::Use(result_operand)) + block.and(Rvalue::Use(Operand::Move(Place::from(result)))) } ExprKind::Cast { source } => { let source = unpack!(block = this.as_operand(block, scope, source)); @@ -171,7 +162,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { .map(|f| unpack!(block = this.as_operand(block, scope, f))) .collect(); - this.record_operands_moved(&fields); block.and(Rvalue::Aggregate(box AggregateKind::Array(el_ty), fields)) } ExprKind::Tuple { fields } => { @@ -182,7 +172,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { .map(|f| unpack!(block = this.as_operand(block, scope, f))) .collect(); - this.record_operands_moved(&fields); block.and(Rvalue::Aggregate(box AggregateKind::Tuple, fields)) } ExprKind::Closure { closure_id, substs, upvars, movability } => { @@ -234,7 +223,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } UpvarSubsts::Closure(substs) => box AggregateKind::Closure(closure_id, substs), }; - this.record_operands_moved(&operands); block.and(Rvalue::Aggregate(result, operands)) } ExprKind::Assign { .. } | ExprKind::AssignOp { .. } => { diff --git a/compiler/rustc_mir_build/src/build/expr/as_temp.rs b/compiler/rustc_mir_build/src/build/expr/as_temp.rs index 241330d96e7..9984b527ffd 100644 --- a/compiler/rustc_mir_build/src/build/expr/as_temp.rs +++ b/compiler/rustc_mir_build/src/build/expr/as_temp.rs @@ -114,7 +114,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } } - unpack!(block = this.into(temp_place, temp_lifetime, block, expr)); + unpack!(block = this.into(temp_place, block, expr)); + + if let Some(temp_lifetime) = temp_lifetime { + this.schedule_drop(expr_span, temp_lifetime, temp, DropKind::Value); + } block.and(temp) } diff --git a/compiler/rustc_mir_build/src/build/expr/into.rs b/compiler/rustc_mir_build/src/build/expr/into.rs index 18ebf334404..235fe14cbf9 100644 --- a/compiler/rustc_mir_build/src/build/expr/into.rs +++ b/compiler/rustc_mir_build/src/build/expr/into.rs @@ -1,35 +1,25 @@ //! See docs in build/expr/mod.rs use crate::build::expr::category::{Category, RvalueFunc}; -use crate::build::scope::DropKind; use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; use crate::thir::*; use rustc_ast::InlineAsmOptions; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stack::ensure_sufficient_stack; use rustc_hir as hir; -use rustc_middle::middle::region; use rustc_middle::mir::*; use rustc_middle::ty::CanonicalUserTypeAnnotation; -use std::slice; - impl<'a, 'tcx> Builder<'a, 'tcx> { /// Compile `expr`, storing the result into `destination`, which /// is assumed to be uninitialized. - /// If a `drop_scope` is provided, `destination` is scheduled to be dropped - /// in `scope` once it has been initialized. crate fn into_expr( &mut self, destination: Place<'tcx>, - scope: Option<region::Scope>, mut block: BasicBlock, expr: Expr<'tcx>, ) -> BlockAnd<()> { - debug!( - "into_expr(destination={:?}, scope={:?}, block={:?}, expr={:?})", - destination, scope, block, expr - ); + debug!("into_expr(destination={:?}, block={:?}, expr={:?})", destination, block, expr); // since we frequently have to reference `self` from within a // closure, where `self` would be shadowed, it's easier to @@ -41,14 +31,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let expr_is_block_or_scope = matches!(expr.kind, ExprKind::Block { .. } | ExprKind::Scope { .. }); - let schedule_drop = move |this: &mut Self| { - if let Some(drop_scope) = scope { - let local = - destination.as_local().expect("cannot schedule drop of non-Local place"); - this.schedule_drop(expr_span, drop_scope, local, DropKind::Value); - } - }; - if !expr_is_block_or_scope { this.block_context.push(BlockFrame::SubExpr); } @@ -58,15 +40,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let region_scope = (region_scope, source_info); ensure_sufficient_stack(|| { this.in_scope(region_scope, lint_level, |this| { - this.into(destination, scope, block, value) + this.into(destination, block, value) }) }) } ExprKind::Block { body: ast_block } => { - this.ast_block(destination, scope, block, ast_block, source_info) + this.ast_block(destination, block, ast_block, source_info) } ExprKind::Match { scrutinee, arms } => { - this.match_expr(destination, scope, expr_span, block, scrutinee, arms) + this.match_expr(destination, expr_span, block, scrutinee, arms) } ExprKind::If { cond, then, else_opt } => { let place = unpack!( @@ -79,9 +61,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let term = TerminatorKind::if_(this.hir.tcx(), operand, then_block, else_block); this.cfg.terminate(block, source_info, term); - unpack!(then_block = this.into(destination, scope, then_block, then)); + unpack!(then_block = this.into(destination, then_block, then)); else_block = if let Some(else_opt) = else_opt { - unpack!(this.into(destination, None, else_block, else_opt)) + unpack!(this.into(destination, else_block, else_opt)) } else { // Body of the `if` expression without an `else` clause must return `()`, thus // we implicitly generate a `else {}` if it is not specified. @@ -117,7 +99,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { // This is an optimization. If the expression was a call then we already have an // unreachable block. Don't bother to terminate it and create a new one. - schedule_drop(this); if is_call { block.unit() } else { @@ -193,35 +174,26 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { // Start the loop. this.cfg.goto(block, source_info, loop_block); - this.in_breakable_scope( - Some(loop_block), - destination, - scope, - expr_span, - move |this| { - // conduct the test, if necessary - let body_block = this.cfg.start_new_block(); - this.cfg.terminate( - loop_block, - source_info, - TerminatorKind::FalseUnwind { real_target: body_block, unwind: None }, - ); - this.diverge_from(loop_block); - - // The “return” value of the loop body must always be an unit. We therefore - // introduce a unit temporary as the destination for the loop body. - let tmp = this.get_unit_temp(); - // Execute the body, branching back to the test. - // We don't need to provide a drop scope because `tmp` - // has type `()`. - let body_block_end = unpack!(this.into(tmp, None, body_block, body)); - this.cfg.goto(body_block_end, source_info, loop_block); - schedule_drop(this); - - // Loops are only exited by `break` expressions. - None - }, - ) + this.in_breakable_scope(Some(loop_block), destination, expr_span, move |this| { + // conduct the test, if necessary + let body_block = this.cfg.start_new_block(); + this.cfg.terminate( + loop_block, + source_info, + TerminatorKind::FalseUnwind { real_target: body_block, unwind: None }, + ); + this.diverge_from(loop_block); + + // The “return” value of the loop body must always be an unit. We therefore + // introduce a unit temporary as the destination for the loop body. + let tmp = this.get_unit_temp(); + // Execute the body, branching back to the test. + let body_block_end = unpack!(this.into(tmp, body_block, body)); + this.cfg.goto(body_block_end, source_info, loop_block); + + // Loops are only exited by `break` expressions. + None + }) } ExprKind::Call { ty: _, fun, args, from_hir_call, fn_span } => { let fun = unpack!(block = this.as_local_operand(block, fun)); @@ -256,10 +228,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { }, ); this.diverge_from(block); - schedule_drop(this); success.unit() } - ExprKind::Use { source } => this.into(destination, scope, block, source), + ExprKind::Use { source } => this.into(destination, block, source), ExprKind::Borrow { arg, borrow_kind } => { // We don't do this in `as_rvalue` because we use `as_place` // for borrow expressions, so we cannot create an `RValue` that @@ -341,14 +312,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { user_ty, active_field_index, ); - this.record_operands_moved(&fields); this.cfg.push_assign( block, source_info, destination, Rvalue::Aggregate(adt, fields), ); - schedule_drop(this); block.unit() } ExprKind::InlineAsm { template, operands, options, line_spans } => { @@ -445,7 +414,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let place = unpack!(block = this.as_place(block, expr)); let rvalue = Rvalue::Use(this.consume_by_copy_or_move(place)); this.cfg.push_assign(block, source_info, destination, rvalue); - schedule_drop(this); block.unit() } ExprKind::Index { .. } | ExprKind::Deref { .. } | ExprKind::Field { .. } => { @@ -463,7 +431,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let place = unpack!(block = this.as_place(block, expr)); let rvalue = Rvalue::Use(this.consume_by_copy_or_move(place)); this.cfg.push_assign(block, source_info, destination, rvalue); - schedule_drop(this); block.unit() } @@ -471,14 +438,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let scope = this.local_scope(); let value = unpack!(block = this.as_operand(block, Some(scope), value)); let resume = this.cfg.start_new_block(); - this.record_operands_moved(slice::from_ref(&value)); this.cfg.terminate( block, source_info, TerminatorKind::Yield { value, resume, resume_arg: destination, drop: None }, ); this.generator_drop_cleanup(block); - schedule_drop(this); resume.unit() } @@ -510,7 +475,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let rvalue = unpack!(block = this.as_local_rvalue(block, expr)); this.cfg.push_assign(block, source_info, destination, rvalue); - schedule_drop(this); block.unit() } }; diff --git a/compiler/rustc_mir_build/src/build/expr/stmt.rs b/compiler/rustc_mir_build/src/build/expr/stmt.rs index a974ea0db5f..f117689d940 100644 --- a/compiler/rustc_mir_build/src/build/expr/stmt.rs +++ b/compiler/rustc_mir_build/src/build/expr/stmt.rs @@ -3,7 +3,6 @@ use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; use crate::thir::*; use rustc_middle::middle::region; use rustc_middle::mir::*; -use std::slice; impl<'a, 'tcx> Builder<'a, 'tcx> { /// Builds a block of MIR statements to evaluate the THIR `expr`. @@ -47,7 +46,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { if this.hir.needs_drop(lhs.ty) { let rhs = unpack!(block = this.as_local_operand(block, rhs)); let lhs = unpack!(block = this.as_place(block, lhs)); - this.record_operands_moved(slice::from_ref(&rhs)); unpack!(block = this.build_drop_and_replace(block, lhs_span, lhs, rhs)); } else { let rhs = unpack!(block = this.as_local_rvalue(block, rhs)); diff --git a/compiler/rustc_mir_build/src/build/into.rs b/compiler/rustc_mir_build/src/build/into.rs index ee1838ddea6..7264e495b84 100644 --- a/compiler/rustc_mir_build/src/build/into.rs +++ b/compiler/rustc_mir_build/src/build/into.rs @@ -6,7 +6,6 @@ use crate::build::{BlockAnd, Builder}; use crate::thir::*; -use rustc_middle::middle::region; use rustc_middle::mir::*; pub(in crate::build) trait EvalInto<'tcx> { @@ -14,7 +13,6 @@ pub(in crate::build) trait EvalInto<'tcx> { self, builder: &mut Builder<'_, 'tcx>, destination: Place<'tcx>, - scope: Option<region::Scope>, block: BasicBlock, ) -> BlockAnd<()>; } @@ -23,14 +21,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { crate fn into<E>( &mut self, destination: Place<'tcx>, - scope: Option<region::Scope>, block: BasicBlock, expr: E, ) -> BlockAnd<()> where E: EvalInto<'tcx>, { - expr.eval_into(self, destination, scope, block) + expr.eval_into(self, destination, block) } } @@ -39,11 +36,10 @@ impl<'tcx> EvalInto<'tcx> for ExprRef<'tcx> { self, builder: &mut Builder<'_, 'tcx>, destination: Place<'tcx>, - scope: Option<region::Scope>, block: BasicBlock, ) -> BlockAnd<()> { let expr = builder.hir.mirror(self); - builder.into_expr(destination, scope, block, expr) + builder.into_expr(destination, block, expr) } } @@ -52,9 +48,8 @@ impl<'tcx> EvalInto<'tcx> for Expr<'tcx> { self, builder: &mut Builder<'_, 'tcx>, destination: Place<'tcx>, - scope: Option<region::Scope>, block: BasicBlock, ) -> BlockAnd<()> { - builder.into_expr(destination, scope, block, self) + builder.into_expr(destination, block, self) } } diff --git a/compiler/rustc_mir_build/src/build/matches/mod.rs b/compiler/rustc_mir_build/src/build/matches/mod.rs index 205ba0d2579..fde007ec011 100644 --- a/compiler/rustc_mir_build/src/build/matches/mod.rs +++ b/compiler/rustc_mir_build/src/build/matches/mod.rs @@ -87,7 +87,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { crate fn match_expr( &mut self, destination: Place<'tcx>, - destination_scope: Option<region::Scope>, span: Span, mut block: BasicBlock, scrutinee: ExprRef<'tcx>, @@ -108,7 +107,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { self.lower_match_arms( destination, - destination_scope, scrutinee_place, scrutinee_span, arm_candidates, @@ -215,13 +213,76 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } } + /// Lower the bindings, guards and arm bodies of a `match` expression. + /// + /// The decision tree should have already been created + /// (by [Builder::lower_match_tree]). + /// + /// `outer_source_info` is the SourceInfo for the whole match. + fn lower_match_arms( + &mut self, + destination: Place<'tcx>, + scrutinee_place: Place<'tcx>, + scrutinee_span: Span, + arm_candidates: Vec<(&'_ Arm<'tcx>, Candidate<'_, 'tcx>)>, + outer_source_info: SourceInfo, + fake_borrow_temps: Vec<(Place<'tcx>, Local)>, + ) -> BlockAnd<()> { + let arm_end_blocks: Vec<_> = arm_candidates + .into_iter() + .map(|(arm, candidate)| { + debug!("lowering arm {:?}\ncandidate = {:?}", arm, candidate); + + let arm_source_info = self.source_info(arm.span); + let arm_scope = (arm.scope, arm_source_info); + self.in_scope(arm_scope, arm.lint_level, |this| { + let body = this.hir.mirror(arm.body.clone()); + let scope = this.declare_bindings( + None, + arm.span, + &arm.pattern, + ArmHasGuard(arm.guard.is_some()), + Some((Some(&scrutinee_place), scrutinee_span)), + ); + + let arm_block = this.bind_pattern( + outer_source_info, + candidate, + arm.guard.as_ref(), + &fake_borrow_temps, + scrutinee_span, + Some(arm.span), + Some(arm.scope), + ); + + if let Some(source_scope) = scope { + this.source_scope = source_scope; + } + + this.into(destination, arm_block, body) + }) + }) + .collect(); + + // all the arm blocks will rejoin here + let end_block = self.cfg.start_new_block(); + + for arm_block in arm_end_blocks { + self.cfg.goto(unpack!(arm_block), outer_source_info, end_block); + } + + self.source_scope = outer_source_info.scope; + + end_block.unit() + } + /// Binds the variables and ascribes types for a given `match` arm or /// `let` binding. /// /// Also check if the guard matches, if it's provided. /// `arm_scope` should be `Some` if and only if this is called for a /// `match` arm. - crate fn bind_pattern( + fn bind_pattern( &mut self, outer_source_info: SourceInfo, candidate: Candidate<'_, 'tcx>, @@ -308,14 +369,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { PatKind::Binding { mode: BindingMode::ByValue, var, subpattern: None, .. } => { let place = self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true); - let region_scope = self.hir.region_scope_tree.var_scope(var.local_id); - - unpack!(block = self.into(place, Some(region_scope), block, initializer)); + unpack!(block = self.into(place, block, initializer)); // Inject a fake read, see comments on `FakeReadCause::ForLet`. let source_info = self.source_info(irrefutable_pat.span); self.cfg.push_fake_read(block, source_info, FakeReadCause::ForLet, place); + self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard); block.unit() } @@ -342,10 +402,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { ascription: thir::pattern::Ascription { user_ty: pat_ascription_ty, variance: _, user_ty_span }, } => { - let region_scope = self.hir.region_scope_tree.var_scope(var.local_id); let place = self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true); - unpack!(block = self.into(place, Some(region_scope), block, initializer)); + unpack!(block = self.into(place, block, initializer)); // Inject a fake read, see comments on `FakeReadCause::ForLet`. let pattern_source_info = self.source_info(irrefutable_pat.span); @@ -383,6 +442,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { }, ); + self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard); block.unit() } @@ -629,7 +689,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } #[derive(Debug)] -pub(super) struct Candidate<'pat, 'tcx> { +struct Candidate<'pat, 'tcx> { /// [`Span`] of the original pattern that gave rise to this candidate. span: Span, diff --git a/compiler/rustc_mir_build/src/build/mod.rs b/compiler/rustc_mir_build/src/build/mod.rs index 8c1f73f4235..5f6c8d26402 100644 --- a/compiler/rustc_mir_build/src/build/mod.rs +++ b/compiler/rustc_mir_build/src/build/mod.rs @@ -618,12 +618,8 @@ where let arg_scope_s = (arg_scope, source_info); // Attribute epilogue to function's closing brace let fn_end = span_with_body.shrink_to_hi(); - let return_block = unpack!(builder.in_breakable_scope( - None, - Place::return_place(), - Some(call_site_scope), - fn_end, - |builder| { + let return_block = + unpack!(builder.in_breakable_scope(None, Place::return_place(), fn_end, |builder| { Some(builder.in_scope(arg_scope_s, LintLevel::Inherited, |builder| { builder.args_and_body( START_BLOCK, @@ -633,13 +629,11 @@ where &body.value, ) })) - }, - )); + })); let source_info = builder.source_info(fn_end); builder.cfg.terminate(return_block, source_info, TerminatorKind::Return); let should_abort = should_abort_on_panic(tcx, fn_def_id, abi); builder.build_drop_trees(should_abort); - builder.unschedule_return_place_drop(); return_block.unit() })); @@ -672,9 +666,7 @@ fn construct_const<'a, 'tcx>( let mut block = START_BLOCK; let ast_expr = &tcx.hir().body(body_id).value; let expr = builder.hir.mirror(ast_expr); - // We don't provide a scope because we can't unwind in constants, so won't - // need to drop the return place. - unpack!(block = builder.into_expr(Place::return_place(), None, block, expr)); + unpack!(block = builder.into_expr(Place::return_place(), block, expr)); let source_info = builder.source_info(span); builder.cfg.terminate(block, source_info, TerminatorKind::Return); @@ -953,9 +945,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } let body = self.hir.mirror(ast_body); - let call_site = - region::Scope { id: ast_body.hir_id.local_id, data: region::ScopeData::CallSite }; - self.into(Place::return_place(), Some(call_site), block, body) + self.into(Place::return_place(), block, body) } fn set_correct_source_scope_for_arg( diff --git a/compiler/rustc_mir_build/src/build/scope.rs b/compiler/rustc_mir_build/src/build/scope.rs index cbc20c6153a..5e9d780d179 100644 --- a/compiler/rustc_mir_build/src/build/scope.rs +++ b/compiler/rustc_mir_build/src/build/scope.rs @@ -81,10 +81,9 @@ that contains only loops and breakable blocks. It tracks where a `break`, */ -use crate::build::matches::{ArmHasGuard, Candidate}; use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder, CFG}; -use crate::thir::{Arm, Expr, ExprRef, LintLevel}; -use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use crate::thir::{Expr, ExprRef, LintLevel}; +use rustc_data_structures::fx::FxHashMap; use rustc_index::vec::IndexVec; use rustc_middle::middle::region; use rustc_middle::mir::*; @@ -121,6 +120,8 @@ struct Scope { /// end of the vector (top of the stack) first. drops: Vec<DropData>, + moved_locals: Vec<Local>, + /// The drop index that will drop everything in and below this scope on an /// unwind path. cached_unwind_block: Option<DropIdx>, @@ -156,8 +157,6 @@ struct BreakableScope<'tcx> { /// The destination of the loop/block expression itself (i.e., where to put /// the result of a `break` or `return` expression) break_destination: Place<'tcx>, - /// The scope that the destination should have its drop scheduled in. - destination_scope: Option<region::Scope>, /// Drops that happen on the `break`/`return` path. break_drops: DropTree, /// Drops that happen on the `continue` path. @@ -406,6 +405,7 @@ impl<'tcx> Scopes<'tcx> { region_scope: region_scope.0, region_scope_span: region_scope.1.span, drops: vec![], + moved_locals: vec![], cached_unwind_block: None, cached_generator_drop_block: None, }); @@ -440,7 +440,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { &mut self, loop_block: Option<BasicBlock>, break_destination: Place<'tcx>, - destination_scope: Option<region::Scope>, span: Span, f: F, ) -> BlockAnd<()> @@ -451,19 +450,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { let scope = BreakableScope { region_scope, break_destination, - destination_scope, break_drops: DropTree::new(), continue_drops: loop_block.map(|_| DropTree::new()), }; - let continue_block = loop_block.map(|block| (block, self.diverge_cleanup())); self.scopes.breakable_scopes.push(scope); let normal_exit_block = f(self); let breakable_scope = self.scopes.breakable_scopes.pop().unwrap(); assert!(breakable_scope.region_scope == region_scope); + let break_block = self.build_exit_tree(breakable_scope.break_drops, None); if let Some(drops) = breakable_scope.continue_drops { - self.build_exit_tree(drops, continue_block); + self.build_exit_tree(drops, loop_block); } - let break_block = self.build_exit_tree(breakable_scope.break_drops, None); match (normal_exit_block, break_block) { (Some(block), None) | (None, Some(block)) => block, (None, None) => self.cfg.start_new_block().unit(), @@ -592,22 +589,22 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { .rposition(|breakable_scope| breakable_scope.region_scope == scope) .unwrap_or_else(|| span_bug!(span, "no enclosing breakable scope found")) }; - let (break_index, destination, dest_scope) = match target { + let (break_index, destination) = match target { BreakableTarget::Return => { let scope = &self.scopes.breakable_scopes[0]; if scope.break_destination != Place::return_place() { span_bug!(span, "`return` in item with no return scope"); } - (0, Some(scope.break_destination), scope.destination_scope) + (0, Some(scope.break_destination)) } BreakableTarget::Break(scope) => { let break_index = get_scope_index(scope); let scope = &self.scopes.breakable_scopes[break_index]; - (break_index, Some(scope.break_destination), scope.destination_scope) + (break_index, Some(scope.break_destination)) } BreakableTarget::Continue(scope) => { let break_index = get_scope_index(scope); - (break_index, None, None) + (break_index, None) } }; @@ -615,10 +612,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { if let Some(value) = value { debug!("stmt_expr Break val block_context.push(SubExpr)"); self.block_context.push(BlockFrame::SubExpr); - unpack!(block = self.into(destination, dest_scope, block, value)); - if let Some(scope) = dest_scope { - self.unschedule_drop(scope, destination.as_local().unwrap()) - }; + unpack!(block = self.into(destination, block, value)); self.block_context.pop(); } else { self.cfg.push_assign_unit(block, source_info, destination, self.hir.tcx()) @@ -858,47 +852,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { span_bug!(span, "region scope {:?} not in scope to drop {:?}", region_scope, local); } - /// Unschedule a drop. Used for `break`, `return` and `match` expressions, - /// where `record_operands_moved` is not powerful enough. - /// - /// The given local is expected to have a value drop scheduled in the given - /// scope and for that drop to be the most recent thing scheduled in that - /// scope. - fn unschedule_drop(&mut self, region_scope: region::Scope, local: Local) { - if !self.hir.needs_drop(self.local_decls[local].ty) { - return; - } - for scope in self.scopes.scopes.iter_mut().rev() { - scope.invalidate_cache(); - - if scope.region_scope == region_scope { - let drop = scope.drops.pop(); - - match drop { - Some(DropData { local: removed_local, kind: DropKind::Value, .. }) - if removed_local == local => - { - return; - } - _ => bug!( - "found wrong drop, expected value drop of {:?}, found {:?}", - local, - drop, - ), - } - } - } - - bug!("region scope {:?} not in scope to unschedule drop of {:?}", region_scope, local); - } - - /// Indicates that the "local operands" stored in `local` is + /// Indicates that the "local operand" stored in `local` is /// *moved* at some point during execution (see `local_scope` for /// more information about what a "local operand" is -- in short, /// it's an intermediate operand created as part of preparing some /// MIR instruction). We use this information to suppress - /// redundant drops. This results in less MIR, but also avoids spurious - /// borrow check errors (c.f. #64391). + /// redundant drops on the non-unwind paths. This results in less + /// MIR, but also avoids spurious borrow check errors + /// (c.f. #64391). /// /// Example: when compiling the call to `foo` here: /// @@ -934,19 +895,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { assert_eq!(scope.region_scope, local_scope, "local scope is not the topmost scope!",); // look for moves of a local variable, like `MOVE(_X)` - let locals_moved = operands - .iter() - .filter_map(|operand| match operand { - Operand::Copy(_) | Operand::Constant(_) => None, - Operand::Move(place) => place.as_local(), - }) - .collect::<FxHashSet<_>>(); + let locals_moved = operands.iter().flat_map(|operand| match operand { + Operand::Copy(_) | Operand::Constant(_) => None, + Operand::Move(place) => place.as_local(), + }); - // Remove the drops for the moved operands. - scope - .drops - .retain(|drop| drop.kind == DropKind::Storage || !locals_moved.contains(&drop.local)); - scope.invalidate_cache(); + for local in locals_moved { + // check if we have a Drop for this operand and -- if so + // -- add it to the list of moved operands. Note that this + // local might not have been an operand created for this + // call, it could come from other places too. + if scope.drops.iter().any(|drop| drop.local == local && drop.kind == DropKind::Value) { + scope.moved_locals.push(local); + } + } } // Other @@ -1133,97 +1095,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { success_block } - /// Lower the arms and guards of a match. - /// - /// The decision tree should have already been created (by - /// [Builder::lower_match_tree]). - /// - /// This is this module, and not in `build::matches` because we have to do - /// some careful scope manipulation to have the drop of the destination be - /// scheduled at the end of each arm and then cleared for the next arm. - crate fn lower_match_arms( - &mut self, - destination: Place<'tcx>, - destination_scope: Option<region::Scope>, - scrutinee_place: Place<'tcx>, - scrutinee_span: Span, - arm_candidates: Vec<(&'_ Arm<'tcx>, Candidate<'_, 'tcx>)>, - outer_source_info: SourceInfo, - fake_borrow_temps: Vec<(Place<'tcx>, Local)>, - ) -> BlockAnd<()> { - if arm_candidates.is_empty() { - // If there are no arms to schedule drops, then we have to do it - // manually. - if let Some(scope) = destination_scope { - self.schedule_drop( - outer_source_info.span, - scope, - destination.as_local().unwrap(), - DropKind::Value, - ); - } - return self.cfg.start_new_block().unit(); - } - let mut first_arm = true; - let arm_end_blocks: Vec<_> = arm_candidates - .into_iter() - .map(|(arm, candidate)| { - debug!("lowering arm {:?}\ncandidate = {:?}", arm, candidate); - - if first_arm { - first_arm = false; - } else if let Some(scope) = destination_scope { - self.unschedule_drop(scope, destination.as_local().unwrap()); - } - - let arm_source_info = self.source_info(arm.span); - let arm_scope = (arm.scope, arm_source_info); - self.in_scope(arm_scope, arm.lint_level, |this| { - let body = this.hir.mirror(arm.body.clone()); - let scope = this.declare_bindings( - None, - arm.span, - &arm.pattern, - ArmHasGuard(arm.guard.is_some()), - Some((Some(&scrutinee_place), scrutinee_span)), - ); - - let arm_block = this.bind_pattern( - outer_source_info, - candidate, - arm.guard.as_ref(), - &fake_borrow_temps, - scrutinee_span, - Some(arm.span), - Some(arm.scope), - ); - - if let Some(source_scope) = scope { - this.source_scope = source_scope; - } - - this.into(destination, destination_scope, arm_block, body) - }) - }) - .collect(); - - // all the arm blocks will rejoin here - let end_block = self.cfg.start_new_block(); - - for arm_block in arm_end_blocks { - self.cfg.goto(unpack!(arm_block), outer_source_info, end_block); - } - - self.source_scope = outer_source_info.scope; - - end_block.unit() - } - /// Unschedules any drops in the top scope. /// /// This is only needed for `match` arm scopes, because they have one /// entrance per pattern, but only one exit. - pub(super) fn clear_top_scope(&mut self, region_scope: region::Scope) { + crate fn clear_top_scope(&mut self, region_scope: region::Scope) { let top_scope = self.scopes.scopes.last_mut().unwrap(); assert_eq!(top_scope.region_scope, region_scope); @@ -1231,18 +1107,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { top_scope.drops.clear(); top_scope.invalidate_cache(); } - - /// Unschedules the drop of the return place. - /// - /// If the return type of a function requires drop, then we schedule it - /// in the outermost scope so that it's dropped if there's a panic while - /// we drop any local variables. But we don't want to drop it if we - /// return normally. - crate fn unschedule_return_place_drop(&mut self) { - assert_eq!(self.scopes.scopes.len(), 1); - assert!(self.scopes.scopes[0].drops.len() <= 1); - self.scopes.scopes[0].drops.clear(); - } } /// Builds drops for `pop_scope` and `leave_top_scope`. @@ -1289,6 +1153,14 @@ fn build_scope_drops<'tcx>( debug_assert_eq!(unwind_drops.drops[unwind_to].0.kind, drop_data.kind); unwind_to = unwind_drops.drops[unwind_to].1; + // If the operand has been moved, and we are not on an unwind + // path, then don't generate the drop. (We only take this into + // account for non-unwind paths so as not to disturb the + // caching mechanism.) + if scope.moved_locals.iter().any(|&o| o == local) { + continue; + } + unwind_drops.add_entry(block, unwind_to); let next = cfg.start_new_block(); @@ -1318,24 +1190,20 @@ impl<'a, 'tcx: 'a> Builder<'a, 'tcx> { /// Build a drop tree for a breakable scope. /// /// If `continue_block` is `Some`, then the tree is for `continue` inside a - /// loop. Otherwise this is for `break` or `return`. The `DropIdx` is the - /// next drop in the case that the drop tree unwinds. This is needed - /// because the drop of the break destination has already been scheduled - /// but it hasn't been initialized on the `continue` paths. + /// loop. Otherwise this is for `break` or `return`. fn build_exit_tree( &mut self, mut drops: DropTree, - continue_block: Option<(BasicBlock, DropIdx)>, + continue_block: Option<BasicBlock>, ) -> Option<BlockAnd<()>> { let mut blocks = IndexVec::from_elem(None, &drops.drops); - blocks[ROOT_NODE] = continue_block.map(|(block, _)| block); + blocks[ROOT_NODE] = continue_block; drops.build_mir::<ExitScopes>(&mut self.cfg, &mut blocks); // Link the exit drop tree to unwind drop tree. if drops.drops.iter().any(|(drop, _)| drop.kind == DropKind::Value) { - let unwind_target = continue_block - .map_or_else(|| self.diverge_cleanup(), |(_, unwind_target)| unwind_target); + let unwind_target = self.diverge_cleanup(); let mut unwind_indices = IndexVec::from_elem_n(unwind_target, 1); for (drop_idx, drop_data) in drops.drops.iter_enumerated().skip(1) { match drop_data.0.kind { diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs index 397706851cb..6ec602ff59b 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs @@ -1,6 +1,6 @@ -use super::usefulness::Usefulness::*; use super::usefulness::{ - compute_match_usefulness, expand_pattern, MatchArm, MatchCheckCtxt, UsefulnessReport, + compute_match_usefulness, expand_pattern, MatchArm, MatchCheckCtxt, Reachability, + UsefulnessReport, }; use super::{PatCtxt, PatKind, PatternError}; @@ -398,10 +398,11 @@ fn report_arm_reachability<'p, 'tcx>( report: &UsefulnessReport<'p, 'tcx>, source: hir::MatchSource, ) { + use Reachability::*; let mut catchall = None; for (arm_index, (arm, is_useful)) in report.arm_usefulness.iter().enumerate() { match is_useful { - NotUseful => { + Unreachable => { match source { hir::MatchSource::WhileDesugar => bug!(), @@ -430,17 +431,16 @@ fn report_arm_reachability<'p, 'tcx>( hir::MatchSource::AwaitDesugar | hir::MatchSource::TryDesugar => {} } } - Useful(unreachables) if unreachables.is_empty() => {} + Reachable(unreachables) if unreachables.is_empty() => {} // The arm is reachable, but contains unreachable subpatterns (from or-patterns). - Useful(unreachables) => { - let mut unreachables: Vec<_> = unreachables.iter().collect(); + Reachable(unreachables) => { + let mut unreachables = unreachables.clone(); // Emit lints in the order in which they occur in the file. unreachables.sort_unstable(); for span in unreachables { unreachable_pattern(cx.tcx, span, arm.hir_id, None); } } - UsefulWithWitness(_) => bug!(), } if !arm.has_guard && catchall.is_none() && pat_is_catchall(arm.pat) { catchall = Some(arm.pat.span); diff --git a/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs index e67166c99c8..3a67eeff92c 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs @@ -723,8 +723,6 @@ impl<'tcx> Constructor<'tcx> { where 'tcx: 'a, { - debug!("Constructor::split({:#?})", self); - match self { Wildcard => { let mut split_wildcard = SplitWildcard::new(pcx); diff --git a/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs b/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs index d7c08a2d1af..f3f21b903ea 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs @@ -288,6 +288,7 @@ use super::{Pat, PatKind}; use super::{PatternFoldable, PatternFolder}; use rustc_data_structures::captures::Captures; +use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync::OnceCell; use rustc_arena::TypedArena; @@ -344,6 +345,12 @@ pub(super) struct PatCtxt<'a, 'p, 'tcx> { pub(super) is_top_level: bool, } +impl<'a, 'p, 'tcx> fmt::Debug for PatCtxt<'a, 'p, 'tcx> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("PatCtxt").field("ty", &self.ty).finish() + } +} + crate fn expand_pattern<'tcx>(pat: Pat<'tcx>) -> Pat<'tcx> { LiteralExpander.fold_pattern(&pat) } @@ -379,11 +386,32 @@ impl<'tcx> Pat<'tcx> { pub(super) fn is_wildcard(&self) -> bool { matches!(*self.kind, PatKind::Binding { subpattern: None, .. } | PatKind::Wild) } + + fn is_or_pat(&self) -> bool { + matches!(*self.kind, PatKind::Or { .. }) + } + + /// Recursively expand this pattern into its subpatterns. Only useful for or-patterns. + fn expand_or_pat(&self) -> Vec<&Self> { + fn expand<'p, 'tcx>(pat: &'p Pat<'tcx>, vec: &mut Vec<&'p Pat<'tcx>>) { + if let PatKind::Or { pats } = pat.kind.as_ref() { + for pat in pats { + expand(pat, vec); + } + } else { + vec.push(pat) + } + } + + let mut pats = Vec::new(); + expand(self, &mut pats); + pats + } } /// A row of a matrix. Rows of len 1 are very common, which is why `SmallVec[_; 2]` /// works well. -#[derive(Debug, Clone)] +#[derive(Clone)] struct PatStack<'p, 'tcx> { pats: SmallVec<[&'p Pat<'tcx>; 2]>, /// Cache for the constructor of the head @@ -419,23 +447,14 @@ impl<'p, 'tcx> PatStack<'p, 'tcx> { self.pats.iter().copied() } - // If the first pattern is an or-pattern, expand this pattern. Otherwise, return `None`. - fn expand_or_pat(&self) -> Option<Vec<Self>> { - if self.is_empty() { - None - } else if let PatKind::Or { pats } = &*self.head().kind { - Some( - pats.iter() - .map(|pat| { - let mut new_patstack = PatStack::from_pattern(pat); - new_patstack.pats.extend_from_slice(&self.pats[1..]); - new_patstack - }) - .collect(), - ) - } else { - None - } + // Recursively expand the first pattern into its subpatterns. Only useful if the pattern is an + // or-pattern. Panics if `self` is empty. + fn expand_or_pat<'a>(&'a self) -> impl Iterator<Item = PatStack<'p, 'tcx>> + Captures<'a> { + self.head().expand_or_pat().into_iter().map(move |pat| { + let mut new_patstack = PatStack::from_pattern(pat); + new_patstack.pats.extend_from_slice(&self.pats[1..]); + new_patstack + }) } /// This computes `S(self.head_ctor(), self)`. See top of the file for explanations. @@ -475,6 +494,17 @@ impl<'p, 'tcx> FromIterator<&'p Pat<'tcx>> for PatStack<'p, 'tcx> { } } +/// Pretty-printing for matrix row. +impl<'p, 'tcx> fmt::Debug for PatStack<'p, 'tcx> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "+")?; + for pat in self.iter() { + write!(f, " {} +", pat)?; + } + Ok(()) + } +} + /// A 2D matrix. #[derive(Clone, PartialEq)] pub(super) struct Matrix<'p, 'tcx> { @@ -491,13 +521,12 @@ impl<'p, 'tcx> Matrix<'p, 'tcx> { self.patterns.get(0).map(|r| r.len()) } - /// Pushes a new row to the matrix. If the row starts with an or-pattern, this expands it. + /// Pushes a new row to the matrix. If the row starts with an or-pattern, this recursively + /// expands it. fn push(&mut self, row: PatStack<'p, 'tcx>) { - if let Some(rows) = row.expand_or_pat() { - for row in rows { - // We recursively expand the or-patterns of the new rows. - // This is necessary as we might have `0 | (1 | 2)` or e.g., `x @ 0 | x @ (1 | 2)`. - self.push(row) + if !row.is_empty() && row.head().is_or_pat() { + for row in row.expand_or_pat() { + self.patterns.push(row); } } else { self.patterns.push(row); @@ -543,17 +572,11 @@ impl<'p, 'tcx> Matrix<'p, 'tcx> { /// Pretty-printer for matrices of patterns, example: /// /// ```text -/// +++++++++++++++++++++++++++++ /// + _ + [] + -/// +++++++++++++++++++++++++++++ /// + true + [First] + -/// +++++++++++++++++++++++++++++ /// + true + [Second(true)] + -/// +++++++++++++++++++++++++++++ /// + false + [_] + -/// +++++++++++++++++++++++++++++ /// + _ + [_, _, tail @ ..] + -/// +++++++++++++++++++++++++++++ /// ``` impl<'p, 'tcx> fmt::Debug for Matrix<'p, 'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { @@ -561,17 +584,14 @@ impl<'p, 'tcx> fmt::Debug for Matrix<'p, 'tcx> { let Matrix { patterns: m, .. } = self; let pretty_printed_matrix: Vec<Vec<String>> = - m.iter().map(|row| row.iter().map(|pat| format!("{:?}", pat)).collect()).collect(); + m.iter().map(|row| row.iter().map(|pat| format!("{}", pat)).collect()).collect(); - let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0); + let column_count = m.iter().map(|row| row.len()).next().unwrap_or(0); assert!(m.iter().all(|row| row.len() == column_count)); let column_widths: Vec<usize> = (0..column_count) .map(|col| pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0)) .collect(); - let total_width = column_widths.iter().cloned().sum::<usize>() + column_count * 3 + 1; - let br = "+".repeat(total_width); - write!(f, "{}\n", br)?; for row in pretty_printed_matrix { write!(f, "+")?; for (column, pat_str) in row.into_iter().enumerate() { @@ -580,7 +600,6 @@ impl<'p, 'tcx> fmt::Debug for Matrix<'p, 'tcx> { write!(f, " +")?; } write!(f, "\n")?; - write!(f, "{}\n", br)?; } Ok(()) } @@ -600,183 +619,318 @@ impl<'p, 'tcx> FromIterator<PatStack<'p, 'tcx>> for Matrix<'p, 'tcx> { } } -/// Represents a set of `Span`s closed under the containment relation. That is, if a `Span` is -/// contained in the set then all `Span`s contained in it are also implicitly contained in the set. -/// In particular this means that when intersecting two sets, taking the intersection of some span -/// and one of its subspans returns the subspan, whereas a simple `HashSet` would have returned an -/// empty intersection. -/// It is assumed that two spans don't overlap without one being contained in the other; in other -/// words, that the inclusion structure forms a tree and not a DAG. -/// Intersection is not very efficient. It compares everything pairwise. If needed it could be made -/// faster by sorting the `Span`s and merging cleverly. -#[derive(Debug, Clone, Default)] -pub(crate) struct SpanSet { - /// The minimal set of `Span`s required to represent the whole set. If A and B are `Span`s in - /// the `SpanSet`, and A is a descendant of B, then only B will be in `root_spans`. - /// Invariant: the spans are disjoint. - root_spans: Vec<Span>, +/// Given a pattern or a pattern-stack, this struct captures a set of its subpatterns. We use that +/// to track reachable sub-patterns arising from or-patterns. In the absence of or-patterns this +/// will always be either `Empty` (the whole pattern is unreachable) or `Full` (the whole pattern +/// is reachable). When there are or-patterns, some subpatterns may be reachable while others +/// aren't. In this case the whole pattern still counts as reachable, but we will lint the +/// unreachable subpatterns. +/// +/// This supports a limited set of operations, so not all possible sets of subpatterns can be +/// represented. That's ok, we only want the ones that make sense for our usage. +/// +/// What we're doing is illustrated by this: +/// ``` +/// match (true, 0) { +/// (true, 0) => {} +/// (_, 1) => {} +/// (true | false, 0 | 1) => {} +/// } +/// ``` +/// When we try the alternatives of the `true | false` or-pattern, the last `0` is reachable in the +/// `false` alternative but not the `true`. So overall it is reachable. By contrast, the last `1` +/// is not reachable in either alternative, so we want to signal this to the user. +/// Therefore we take the union of sets of reachable patterns coming from different alternatives in +/// order to figure out which subpatterns are overall reachable. +/// +/// Invariant: we try to construct the smallest representation we can. In particular if +/// `self.is_empty()` we ensure that `self` is `Empty`, and same with `Full`. This is not important +/// for correctness currently. +#[derive(Debug, Clone)] +enum SubPatSet<'p, 'tcx> { + /// The empty set. This means the pattern is unreachable. + Empty, + /// The set containing the full pattern. + Full, + /// If the pattern is a pattern with a constructor or a pattern-stack, we store a set for each + /// of its subpatterns. Missing entries in the map are implicitly full, because that's the + /// common case. + Seq { subpats: FxHashMap<usize, SubPatSet<'p, 'tcx>> }, + /// If the pattern is an or-pattern, we store a set for each of its alternatives. Missing + /// entries in the map are implicitly empty. Note: we always flatten nested or-patterns. + Alt { + subpats: FxHashMap<usize, SubPatSet<'p, 'tcx>>, + /// Counts the total number of alternatives in the pattern + alt_count: usize, + /// We keep the pattern around to retrieve spans. + pat: &'p Pat<'tcx>, + }, } -impl SpanSet { - /// Creates an empty set. - fn new() -> Self { - Self::default() - } - - /// Tests whether the set is empty. - pub(crate) fn is_empty(&self) -> bool { - self.root_spans.is_empty() +impl<'p, 'tcx> SubPatSet<'p, 'tcx> { + fn full() -> Self { + SubPatSet::Full } - - /// Iterate over the disjoint list of spans at the roots of this set. - pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = Span> + Captures<'a> { - self.root_spans.iter().copied() + fn empty() -> Self { + SubPatSet::Empty } - /// Tests whether the set contains a given Span. - fn contains(&self, span: Span) -> bool { - self.iter().any(|root_span| root_span.contains(span)) + fn is_empty(&self) -> bool { + match self { + SubPatSet::Empty => true, + SubPatSet::Full => false, + // If any subpattern in a sequence is unreachable, the whole pattern is unreachable. + SubPatSet::Seq { subpats } => subpats.values().any(|set| set.is_empty()), + // An or-pattern is reachable if any of its alternatives is. + SubPatSet::Alt { subpats, .. } => subpats.values().all(|set| set.is_empty()), + } } - /// Add a span to the set if we know the span has no intersection in this set. - fn push_nonintersecting(&mut self, new_span: Span) { - self.root_spans.push(new_span); + fn is_full(&self) -> bool { + match self { + SubPatSet::Empty => false, + SubPatSet::Full => true, + // The whole pattern is reachable only when all its alternatives are. + SubPatSet::Seq { subpats } => subpats.values().all(|sub_set| sub_set.is_full()), + // The whole or-pattern is reachable only when all its alternatives are. + SubPatSet::Alt { subpats, alt_count, .. } => { + subpats.len() == *alt_count && subpats.values().all(|set| set.is_full()) + } + } } - fn intersection_mut(&mut self, other: &Self) { - if self.is_empty() || other.is_empty() { - *self = Self::new(); + /// Union `self` with `other`, mutating `self`. + fn union(&mut self, other: Self) { + use SubPatSet::*; + // Union with full stays full; union with empty changes nothing. + if self.is_full() || other.is_empty() { + return; + } else if self.is_empty() { + *self = other; + return; + } else if other.is_full() { + *self = Full; return; } - // Those that were in `self` but not contained in `other` - let mut leftover = SpanSet::new(); - // We keep the elements in `self` that are also in `other`. - self.root_spans.retain(|span| { - let retain = other.contains(*span); - if !retain { - leftover.root_spans.push(*span); + + match (&mut *self, other) { + (Seq { subpats: s_set }, Seq { subpats: mut o_set }) => { + s_set.retain(|i, s_sub_set| { + // Missing entries count as full. + let o_sub_set = o_set.remove(&i).unwrap_or(Full); + s_sub_set.union(o_sub_set); + // We drop full entries. + !s_sub_set.is_full() + }); + // Everything left in `o_set` is missing from `s_set`, i.e. counts as full. Since + // unioning with full returns full, we can drop those entries. } - retain - }); - // We keep the elements in `other` that are also in the original `self`. You might think - // this is not needed because `self` already contains the intersection. But those aren't - // just sets of things. If `self = [a]`, `other = [b]` and `a` contains `b`, then `b` - // belongs in the intersection but we didn't catch it in the filtering above. We look at - // `leftover` instead of the full original `self` to avoid duplicates. - for span in other.iter() { - if leftover.contains(span) { - self.root_spans.push(span); + (Alt { subpats: s_set, .. }, Alt { subpats: mut o_set, .. }) => { + s_set.retain(|i, s_sub_set| { + // Missing entries count as empty. + let o_sub_set = o_set.remove(&i).unwrap_or(Empty); + s_sub_set.union(o_sub_set); + // We drop empty entries. + !s_sub_set.is_empty() + }); + // Everything left in `o_set` is missing from `s_set`, i.e. counts as empty. Since + // unioning with empty changes nothing, we can take those entries as is. + s_set.extend(o_set); + } + _ => bug!(), + } + + if self.is_full() { + *self = Full; + } + } + + /// Returns a list of the spans of the unreachable subpatterns. If `self` is empty (i.e. the + /// whole pattern is unreachable) we return `None`. + fn list_unreachable_spans(&self) -> Option<Vec<Span>> { + /// Panics if `set.is_empty()`. + fn fill_spans(set: &SubPatSet<'_, '_>, spans: &mut Vec<Span>) { + match set { + SubPatSet::Empty => bug!(), + SubPatSet::Full => {} + SubPatSet::Seq { subpats } => { + for (_, sub_set) in subpats { + fill_spans(sub_set, spans); + } + } + SubPatSet::Alt { subpats, pat, alt_count, .. } => { + let expanded = pat.expand_or_pat(); + for i in 0..*alt_count { + let sub_set = subpats.get(&i).unwrap_or(&SubPatSet::Empty); + if sub_set.is_empty() { + // Found a unreachable subpattern. + spans.push(expanded[i].span); + } else { + fill_spans(sub_set, spans); + } + } + } } } + + if self.is_empty() { + return None; + } + if self.is_full() { + // No subpatterns are unreachable. + return Some(Vec::new()); + } + let mut spans = Vec::new(); + fill_spans(self, &mut spans); + Some(spans) + } + + /// When `self` refers to a patstack that was obtained from specialization, after running + /// `unspecialize` it will refer to the original patstack before specialization. + fn unspecialize(self, arity: usize) -> Self { + use SubPatSet::*; + match self { + Full => Full, + Empty => Empty, + Seq { subpats } => { + // We gather the first `arity` subpatterns together and shift the remaining ones. + let mut new_subpats = FxHashMap::default(); + let mut new_subpats_first_col = FxHashMap::default(); + for (i, sub_set) in subpats { + if i < arity { + // The first `arity` indices are now part of the pattern in the first + // column. + new_subpats_first_col.insert(i, sub_set); + } else { + // Indices after `arity` are simply shifted + new_subpats.insert(i - arity + 1, sub_set); + } + } + // If `new_subpats_first_col` has no entries it counts as full, so we can omit it. + if !new_subpats_first_col.is_empty() { + new_subpats.insert(0, Seq { subpats: new_subpats_first_col }); + } + Seq { subpats: new_subpats } + } + Alt { .. } => bug!(), // `self` is a patstack + } + } + + /// When `self` refers to a patstack that was obtained from splitting an or-pattern, after + /// running `unspecialize` it will refer to the original patstack before splitting. + /// + /// For example: + /// ``` + /// match Some(true) { + /// Some(true) => {} + /// None | Some(true | false) => {} + /// } + /// ``` + /// Here `None` would return the full set and `Some(true | false)` would return the set + /// containing `false`. After `unsplit_or_pat`, we want the set to contain `None` and `false`. + /// This is what this function does. + fn unsplit_or_pat(mut self, alt_id: usize, alt_count: usize, pat: &'p Pat<'tcx>) -> Self { + use SubPatSet::*; + if self.is_empty() { + return Empty; + } + + // Subpatterns coming from inside the or-pattern alternative itself, e.g. in `None | Some(0 + // | 1)`. + let set_first_col = match &mut self { + Full => Full, + Seq { subpats } => subpats.remove(&0).unwrap_or(Full), + Empty => unreachable!(), + Alt { .. } => bug!(), // `self` is a patstack + }; + let mut subpats_first_col = FxHashMap::default(); + subpats_first_col.insert(alt_id, set_first_col); + let set_first_col = Alt { subpats: subpats_first_col, pat, alt_count }; + + let mut subpats = match self { + Full => FxHashMap::default(), + Seq { subpats } => subpats, + Empty => unreachable!(), + Alt { .. } => bug!(), // `self` is a patstack + }; + subpats.insert(0, set_first_col); + Seq { subpats } } } +/// This carries the results of computing usefulness, as described at the top of the file. When +/// checking usefulness of a match branch, we use the `NoWitnesses` variant, which also keeps track +/// of potential unreachable sub-patterns (in the presence of or-patterns). When checking +/// exhaustiveness of a whole match, we use the `WithWitnesses` variant, which carries a list of +/// witnesses of non-exhaustiveness when there are any. +/// Which variant to use is dictated by `WitnessPreference`. #[derive(Clone, Debug)] -crate enum Usefulness<'tcx> { - /// Pontentially carries a set of sub-branches that have been found to be unreachable. Used - /// only in the presence of or-patterns, otherwise it stays empty. - Useful(SpanSet), - /// Carries a list of witnesses of non-exhaustiveness. - UsefulWithWitness(Vec<Witness<'tcx>>), - NotUseful, +enum Usefulness<'p, 'tcx> { + /// Carries a set of subpatterns that have been found to be reachable. If empty, this indicates + /// the whole pattern is unreachable. If not, this indicates that the pattern is reachable but + /// that some sub-patterns may be unreachable (due to or-patterns). In the absence of + /// or-patterns this will always be either `Empty` (the whole pattern is unreachable) or `Full` + /// (the whole pattern is reachable). + NoWitnesses(SubPatSet<'p, 'tcx>), + /// Carries a list of witnesses of non-exhaustiveness. If empty, indicates that the whole + /// pattern is unreachable. + WithWitnesses(Vec<Witness<'tcx>>), } -impl<'tcx> Usefulness<'tcx> { +impl<'p, 'tcx> Usefulness<'p, 'tcx> { fn new_useful(preference: WitnessPreference) -> Self { match preference { - ConstructWitness => UsefulWithWitness(vec![Witness(vec![])]), - LeaveOutWitness => Useful(Default::default()), + ConstructWitness => WithWitnesses(vec![Witness(vec![])]), + LeaveOutWitness => NoWitnesses(SubPatSet::full()), + } + } + fn new_not_useful(preference: WitnessPreference) -> Self { + match preference { + ConstructWitness => WithWitnesses(vec![]), + LeaveOutWitness => NoWitnesses(SubPatSet::empty()), + } + } + + /// Combine usefulnesses from two branches. This is an associative operation. + fn extend(&mut self, other: Self) { + match (&mut *self, other) { + (WithWitnesses(_), WithWitnesses(o)) if o.is_empty() => {} + (WithWitnesses(s), WithWitnesses(o)) if s.is_empty() => *self = WithWitnesses(o), + (WithWitnesses(s), WithWitnesses(o)) => s.extend(o), + (NoWitnesses(s), NoWitnesses(o)) => s.union(o), + _ => unreachable!(), } } /// When trying several branches and each returns a `Usefulness`, we need to combine the /// results together. - fn merge(usefulnesses: impl Iterator<Item = Self>) -> Self { - // If we have detected some unreachable sub-branches, we only want to keep them when they - // were unreachable in _all_ branches. Eg. in the following, the last `true` is unreachable - // in the second branch of the first or-pattern, but not otherwise. Therefore we don't want - // to lint that it is unreachable. - // ``` - // match (true, true) { - // (true, true) => {} - // (false | true, false | true) => {} - // } - // ``` - // Here however we _do_ want to lint that the last `false` is unreachable. So we don't want - // to intersect the spans that come directly from the or-pattern, since each branch of the - // or-pattern brings a new disjoint pattern. - // ``` - // match None { - // Some(false) => {} - // None | Some(true | false) => {} - // } - // ``` - - // Is `None` when no branch was useful. Will often be `Some(Spanset::new())` because the - // sets are only non-empty in the presence of or-patterns. - let mut unreachables: Option<SpanSet> = None; - // Witnesses of usefulness, if any. - let mut witnesses = Vec::new(); - + fn merge(pref: WitnessPreference, usefulnesses: impl Iterator<Item = Self>) -> Self { + let mut ret = Self::new_not_useful(pref); for u in usefulnesses { - match u { - Useful(spans) if spans.is_empty() => { - // Once we reach the empty set, more intersections won't change the result. - return Useful(SpanSet::new()); - } - Useful(spans) => { - if let Some(unreachables) = &mut unreachables { - if !unreachables.is_empty() { - unreachables.intersection_mut(&spans); - } - if unreachables.is_empty() { - return Useful(SpanSet::new()); - } - } else { - unreachables = Some(spans); - } - } - NotUseful => {} - UsefulWithWitness(wits) => { - witnesses.extend(wits); + ret.extend(u); + if let NoWitnesses(subpats) = &ret { + if subpats.is_full() { + // Once we reach the full set, more unions won't change the result. + return ret; } } } - - if !witnesses.is_empty() { - UsefulWithWitness(witnesses) - } else if let Some(unreachables) = unreachables { - Useful(unreachables) - } else { - NotUseful - } + ret } /// After calculating the usefulness for a branch of an or-pattern, call this to make this /// usefulness mergeable with those from the other branches. - fn unsplit_or_pat(self, this_span: Span, or_pat_spans: &[Span]) -> Self { + fn unsplit_or_pat(self, alt_id: usize, alt_count: usize, pat: &'p Pat<'tcx>) -> Self { match self { - Useful(mut spans) => { - // We register the spans of the other branches of this or-pattern as being - // unreachable from this one. This ensures that intersecting together the sets of - // spans returns what we want. - // Until we optimize `SpanSet` however, intersecting this entails a number of - // comparisons quadratic in the number of branches. - for &span in or_pat_spans { - if span != this_span { - spans.push_nonintersecting(span); - } - } - Useful(spans) - } - x => x, + NoWitnesses(subpats) => NoWitnesses(subpats.unsplit_or_pat(alt_id, alt_count, pat)), + WithWitnesses(_) => bug!(), } } /// After calculating usefulness after a specialization, call this to recontruct a usefulness /// that makes sense for the matrix pre-specialization. This new usefulness can then be merged /// with the results of specializing with the other constructors. - fn apply_constructor<'p>( + fn apply_constructor( self, pcx: PatCtxt<'_, 'p, 'tcx>, matrix: &Matrix<'p, 'tcx>, // used to compute missing ctors @@ -784,7 +938,8 @@ impl<'tcx> Usefulness<'tcx> { ctor_wild_subpatterns: &Fields<'p, 'tcx>, ) -> Self { match self { - UsefulWithWitness(witnesses) => { + WithWitnesses(witnesses) if witnesses.is_empty() => WithWitnesses(witnesses), + WithWitnesses(witnesses) => { let new_witnesses = if matches!(ctor, Constructor::Missing) { let mut split_wildcard = SplitWildcard::new(pcx); split_wildcard.split(pcx, matrix.head_ctors(pcx.cx)); @@ -814,9 +969,9 @@ impl<'tcx> Usefulness<'tcx> { .map(|witness| witness.apply_constructor(pcx, &ctor, ctor_wild_subpatterns)) .collect() }; - UsefulWithWitness(new_witnesses) + WithWitnesses(new_witnesses) } - x => x, + NoWitnesses(subpats) => NoWitnesses(subpats.unspecialize(ctor_wild_subpatterns.len())), } } } @@ -924,6 +1079,7 @@ impl<'tcx> Witness<'tcx> { /// `is_under_guard` is used to inform if the pattern has a guard. If it /// has one it must not be inserted into the matrix. This shouldn't be /// relied on for soundness. +#[instrument(skip(cx, matrix, witness_preference, hir_id, is_under_guard, is_top_level))] fn is_useful<'p, 'tcx>( cx: &MatchCheckCtxt<'p, 'tcx>, matrix: &Matrix<'p, 'tcx>, @@ -932,9 +1088,9 @@ fn is_useful<'p, 'tcx>( hir_id: HirId, is_under_guard: bool, is_top_level: bool, -) -> Usefulness<'tcx> { +) -> Usefulness<'p, 'tcx> { + debug!("matrix,v={:?}{:?}", matrix, v); let Matrix { patterns: rows, .. } = matrix; - debug!("is_useful({:#?}, {:#?})", matrix, v); // The base case. We are pattern-matching on () and the return value is // based on whether our matrix has a row or not. @@ -942,12 +1098,14 @@ fn is_useful<'p, 'tcx>( // first and then, if v is non-empty, the return value is based on whether // the type of the tuple we're checking is inhabited or not. if v.is_empty() { - return if rows.is_empty() { + let ret = if rows.is_empty() { Usefulness::new_useful(witness_preference) } else { - NotUseful + Usefulness::new_not_useful(witness_preference) }; - }; + debug!(?ret); + return ret; + } assert!(rows.iter().all(|r| r.len() == v.len())); @@ -955,16 +1113,15 @@ fn is_useful<'p, 'tcx>( let ty = matrix.heads().next().map_or(v.head().ty, |r| r.ty); let pcx = PatCtxt { cx, ty, span: v.head().span, is_top_level }; - debug!("is_useful_expand_first_col: ty={:#?}, expanding {:#?}", pcx.ty, v.head()); - // If the first pattern is an or-pattern, expand it. - let ret = if let Some(vs) = v.expand_or_pat() { - let subspans: Vec<_> = vs.iter().map(|v| v.head().span).collect(); - // We expand the or pattern, trying each of its branches in turn and keeping careful track - // of possible unreachable sub-branches. + let ret = if v.head().is_or_pat() { + debug!("expanding or-pattern"); + let v_head = v.head(); + let vs: Vec<_> = v.expand_or_pat().collect(); + let alt_count = vs.len(); + // We try each or-pattern branch in turn. let mut matrix = matrix.clone(); - let usefulnesses = vs.into_iter().map(|v| { - let v_span = v.head().span; + let usefulnesses = vs.into_iter().enumerate().map(|(i, v)| { let usefulness = is_useful(cx, &matrix, &v, witness_preference, hir_id, is_under_guard, false); // If pattern has a guard don't add it to the matrix. @@ -973,9 +1130,9 @@ fn is_useful<'p, 'tcx>( // branches like `Some(_) | Some(0)`. matrix.push(v); } - usefulness.unsplit_or_pat(v_span, &subspans) + usefulness.unsplit_or_pat(i, alt_count, v_head) }); - Usefulness::merge(usefulnesses) + Usefulness::merge(witness_preference, usefulnesses) } else { let v_ctor = v.head_ctor(cx); if let Constructor::IntRange(ctor_range) = &v_ctor { @@ -993,6 +1150,7 @@ fn is_useful<'p, 'tcx>( // witness the usefulness of `v`. let start_matrix = &matrix; let usefulnesses = split_ctors.into_iter().map(|ctor| { + debug!("specialize({:?})", ctor); // We cache the result of `Fields::wildcards` because it is used a lot. let ctor_wild_subpatterns = Fields::wildcards(pcx, &ctor); let spec_matrix = @@ -1002,9 +1160,9 @@ fn is_useful<'p, 'tcx>( is_useful(cx, &spec_matrix, &v, witness_preference, hir_id, is_under_guard, false); usefulness.apply_constructor(pcx, start_matrix, &ctor, &ctor_wild_subpatterns) }); - Usefulness::merge(usefulnesses) + Usefulness::merge(witness_preference, usefulnesses) }; - debug!("is_useful::returns({:#?}, {:#?}) = {:?}", matrix, v, ret); + debug!(?ret); ret } @@ -1017,10 +1175,21 @@ crate struct MatchArm<'p, 'tcx> { crate has_guard: bool, } +/// Indicates whether or not a given arm is reachable. +#[derive(Clone, Debug)] +crate enum Reachability { + /// The arm is reachable. This additionally carries a set of or-pattern branches that have been + /// found to be unreachable despite the overall arm being reachable. Used only in the presence + /// of or-patterns, otherwise it stays empty. + Reachable(Vec<Span>), + /// The arm is unreachable. + Unreachable, +} + /// The output of checking a match for exhaustiveness and arm reachability. crate struct UsefulnessReport<'p, 'tcx> { /// For each arm of the input, whether that arm is reachable after the arms above it. - crate arm_usefulness: Vec<(MatchArm<'p, 'tcx>, Usefulness<'tcx>)>, + crate arm_usefulness: Vec<(MatchArm<'p, 'tcx>, Reachability)>, /// If the match is exhaustive, this is empty. If not, this contains witnesses for the lack of /// exhaustiveness. crate non_exhaustiveness_witnesses: Vec<super::Pat<'tcx>>, @@ -1048,7 +1217,14 @@ crate fn compute_match_usefulness<'p, 'tcx>( if !arm.has_guard { matrix.push(v); } - (arm, usefulness) + let reachability = match usefulness { + NoWitnesses(subpats) if subpats.is_empty() => Reachability::Unreachable, + NoWitnesses(subpats) => { + Reachability::Reachable(subpats.list_unreachable_spans().unwrap()) + } + WithWitnesses(..) => bug!(), + }; + (arm, reachability) }) .collect(); @@ -1056,15 +1232,8 @@ crate fn compute_match_usefulness<'p, 'tcx>( let v = PatStack::from_pattern(wild_pattern); let usefulness = is_useful(cx, &matrix, &v, ConstructWitness, scrut_hir_id, false, true); let non_exhaustiveness_witnesses = match usefulness { - NotUseful => vec![], // Wildcard pattern isn't useful, so the match is exhaustive. - UsefulWithWitness(pats) => { - if pats.is_empty() { - bug!("Exhaustiveness check returned no witnesses") - } else { - pats.into_iter().map(|w| w.single_pattern()).collect() - } - } - Useful(_) => bug!(), + WithWitnesses(pats) => pats.into_iter().map(|w| w.single_pattern()).collect(), + NoWitnesses(_) => bug!(), }; UsefulnessReport { arm_usefulness, non_exhaustiveness_witnesses } } diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs index b5b34c7338d..4a638ec3f80 100644 --- a/compiler/rustc_parse/src/lexer/mod.rs +++ b/compiler/rustc_parse/src/lexer/mod.rs @@ -14,7 +14,7 @@ mod tokentrees; mod unescape_error_reporting; mod unicode_chars; -use unescape_error_reporting::{emit_unescape_error, push_escaped_char}; +use unescape_error_reporting::{emit_unescape_error, escaped_char}; #[derive(Clone, Debug)] pub struct UnmatchedBrace { @@ -122,11 +122,9 @@ impl<'a> StringReader<'a> { m: &str, c: char, ) -> DiagnosticBuilder<'a> { - let mut m = m.to_string(); - m.push_str(": "); - push_escaped_char(&mut m, c); - - self.sess.span_diagnostic.struct_span_fatal(self.mk_sp(from_pos, to_pos), &m[..]) + self.sess + .span_diagnostic + .struct_span_fatal(self.mk_sp(from_pos, to_pos), &format!("{}: {}", m, escaped_char(c))) } /// Turns simple `rustc_lexer::TokenKind` enum into a rich @@ -421,7 +419,7 @@ impl<'a> StringReader<'a> { let content_start = start + BytePos(prefix_len); let content_end = suffix_start - BytePos(postfix_len); let id = self.symbol_from_to(content_start, content_end); - self.validate_literal_escape(mode, content_start, content_end); + self.validate_literal_escape(mode, content_start, content_end, prefix_len, postfix_len); (lit_kind, id) } @@ -525,17 +523,29 @@ impl<'a> StringReader<'a> { .raise(); } - fn validate_literal_escape(&self, mode: Mode, content_start: BytePos, content_end: BytePos) { + fn validate_literal_escape( + &self, + mode: Mode, + content_start: BytePos, + content_end: BytePos, + prefix_len: u32, + postfix_len: u32, + ) { let lit_content = self.str_from_to(content_start, content_end); unescape::unescape_literal(lit_content, mode, &mut |range, result| { // Here we only check for errors. The actual unescaping is done later. if let Err(err) = result { - let span_with_quotes = - self.mk_sp(content_start - BytePos(1), content_end + BytePos(1)); + let span_with_quotes = self + .mk_sp(content_start - BytePos(prefix_len), content_end + BytePos(postfix_len)); + let (start, end) = (range.start as u32, range.end as u32); + let lo = content_start + BytePos(start); + let hi = lo + BytePos(end - start); + let span = self.mk_sp(lo, hi); emit_unescape_error( &self.sess.span_diagnostic, lit_content, span_with_quotes, + span, mode, range, err, diff --git a/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs b/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs index 47d317f9188..a580f0c55d0 100644 --- a/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs +++ b/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs @@ -13,6 +13,8 @@ pub(crate) fn emit_unescape_error( lit: &str, // full span of the literal, including quotes span_with_quotes: Span, + // interior span of the literal, without quotes + span: Span, mode: Mode, // range of the error inside `lit` range: Range<usize>, @@ -26,13 +28,6 @@ pub(crate) fn emit_unescape_error( range, error ); - let span = { - let Range { start, end } = range; - let (start, end) = (start as u32, end as u32); - let lo = span_with_quotes.lo() + BytePos(start + 1); - let hi = lo + BytePos(end - start); - span_with_quotes.with_lo(lo).with_hi(hi) - }; let last_char = || { let c = lit[range.clone()].chars().rev().next().unwrap(); let span = span.with_lo(span.hi() - BytePos(c.len_utf8() as u32)); @@ -42,20 +37,22 @@ pub(crate) fn emit_unescape_error( EscapeError::LoneSurrogateUnicodeEscape => { handler .struct_span_err(span, "invalid unicode character escape") + .span_label(span, "invalid escape") .help("unicode escape must not be a surrogate") .emit(); } EscapeError::OutOfRangeUnicodeEscape => { handler .struct_span_err(span, "invalid unicode character escape") + .span_label(span, "invalid escape") .help("unicode escape must be at most 10FFFF") .emit(); } EscapeError::MoreThanOneChar => { - let msg = if mode.is_bytes() { - "if you meant to write a byte string literal, use double quotes" + let (prefix, msg) = if mode.is_bytes() { + ("b", "if you meant to write a byte string literal, use double quotes") } else { - "if you meant to write a `str` literal, use double quotes" + ("", "if you meant to write a `str` literal, use double quotes") }; handler @@ -66,31 +63,44 @@ pub(crate) fn emit_unescape_error( .span_suggestion( span_with_quotes, msg, - format!("\"{}\"", lit), + format!("{}\"{}\"", prefix, lit), Applicability::MachineApplicable, ) .emit(); } EscapeError::EscapeOnlyChar => { - let (c, _span) = last_char(); + let (c, char_span) = last_char(); - let mut msg = if mode.is_bytes() { - "byte constant must be escaped: " + let msg = if mode.is_bytes() { + "byte constant must be escaped" } else { - "character constant must be escaped: " - } - .to_string(); - push_escaped_char(&mut msg, c); - - handler.span_err(span, msg.as_str()) + "character constant must be escaped" + }; + handler + .struct_span_err(span, &format!("{}: `{}`", msg, escaped_char(c))) + .span_suggestion( + char_span, + "escape the character", + c.escape_default().to_string(), + Applicability::MachineApplicable, + ) + .emit() } EscapeError::BareCarriageReturn => { let msg = if mode.in_double_quotes() { - "bare CR not allowed in string, use \\r instead" + "bare CR not allowed in string, use `\\r` instead" } else { - "character constant must be escaped: \\r" + "character constant must be escaped: `\\r`" }; - handler.span_err(span, msg); + handler + .struct_span_err(span, msg) + .span_suggestion( + span, + "escape the character", + "\\r".to_string(), + Applicability::MachineApplicable, + ) + .emit(); } EscapeError::BareCarriageReturnInRawString => { assert!(mode.in_double_quotes()); @@ -102,21 +112,22 @@ pub(crate) fn emit_unescape_error( let label = if mode.is_bytes() { "unknown byte escape" } else { "unknown character escape" }; - let mut msg = label.to_string(); - msg.push_str(": "); - push_escaped_char(&mut msg, c); - - let mut diag = handler.struct_span_err(span, msg.as_str()); + let ec = escaped_char(c); + let mut diag = handler.struct_span_err(span, &format!("{}: `{}`", label, ec)); diag.span_label(span, label); if c == '{' || c == '}' && !mode.is_bytes() { diag.help( - "if used in a formatting string, \ - curly braces are escaped with `{{` and `}}`", + "if used in a formatting string, curly braces are escaped with `{{` and `}}`", ); } else if c == '\r' { diag.help( - "this is an isolated carriage return; \ - consider checking your editor and version control settings", + "this is an isolated carriage return; consider checking your editor and \ + version control settings", + ); + } else { + diag.help( + "for more information, visit \ + <https://static.rust-lang.org/doc/master/reference.html#literals>", ); } diag.emit(); @@ -127,45 +138,70 @@ pub(crate) fn emit_unescape_error( EscapeError::InvalidCharInHexEscape | EscapeError::InvalidCharInUnicodeEscape => { let (c, span) = last_char(); - let mut msg = if error == EscapeError::InvalidCharInHexEscape { - "invalid character in numeric character escape: " + let msg = if error == EscapeError::InvalidCharInHexEscape { + "invalid character in numeric character escape" } else { - "invalid character in unicode escape: " - } - .to_string(); - push_escaped_char(&mut msg, c); + "invalid character in unicode escape" + }; + let c = escaped_char(c); - handler.span_err(span, msg.as_str()) + handler + .struct_span_err(span, &format!("{}: `{}`", msg, c)) + .span_label(span, msg) + .emit(); } EscapeError::NonAsciiCharInByte => { assert!(mode.is_bytes()); - let (_c, span) = last_char(); - handler.span_err( - span, - "byte constant must be ASCII. \ - Use a \\xHH escape for a non-ASCII byte", - ) + let (c, span) = last_char(); + handler + .struct_span_err(span, "non-ASCII character in byte constant") + .span_label(span, "byte constant must be ASCII") + .span_suggestion( + span, + "use a \\xHH escape for a non-ASCII byte", + format!("\\x{:X}", c as u32), + Applicability::MachineApplicable, + ) + .emit(); } EscapeError::NonAsciiCharInByteString => { assert!(mode.is_bytes()); let (_c, span) = last_char(); - handler.span_err(span, "raw byte string must be ASCII") + handler + .struct_span_err(span, "raw byte string must be ASCII") + .span_label(span, "must be ASCII") + .emit(); + } + EscapeError::OutOfRangeHexEscape => { + handler + .struct_span_err(span, "out of range hex escape") + .span_label(span, "must be a character in the range [\\x00-\\x7f]") + .emit(); } - EscapeError::OutOfRangeHexEscape => handler.span_err( - span, - "this form of character escape may only be used \ - with characters in the range [\\x00-\\x7f]", - ), EscapeError::LeadingUnderscoreUnicodeEscape => { - let (_c, span) = last_char(); - handler.span_err(span, "invalid start of unicode escape") + let (c, span) = last_char(); + let msg = "invalid start of unicode escape"; + handler + .struct_span_err(span, &format!("{}: `{}`", msg, c)) + .span_label(span, msg) + .emit(); } EscapeError::OverlongUnicodeEscape => { - handler.span_err(span, "overlong unicode escape (must have at most 6 hex digits)") - } - EscapeError::UnclosedUnicodeEscape => { - handler.span_err(span, "unterminated unicode escape (needed a `}`)") + handler + .struct_span_err(span, "overlong unicode escape") + .span_label(span, "must have at most 6 hex digits") + .emit(); } + EscapeError::UnclosedUnicodeEscape => handler + .struct_span_err(span, "unterminated unicode escape") + .span_label(span, "missing a closing `}`") + .span_suggestion_verbose( + span.shrink_to_hi(), + "terminate the unicode escape", + "}".to_string(), + Applicability::MaybeIncorrect, + ) + .emit(), EscapeError::NoBraceInUnicodeEscape => { let msg = "incorrect unicode escape sequence"; let mut diag = handler.struct_span_err(span, msg); @@ -195,28 +231,38 @@ pub(crate) fn emit_unescape_error( diag.emit(); } - EscapeError::UnicodeEscapeInByte => handler.span_err( - span, - "unicode escape sequences cannot be used \ - as a byte or in a byte string", - ), + EscapeError::UnicodeEscapeInByte => { + let msg = "unicode escape in byte string"; + handler + .struct_span_err(span, msg) + .span_label(span, msg) + .help("unicode escape sequences cannot be used as a byte or in a byte string") + .emit(); + } EscapeError::EmptyUnicodeEscape => { - handler.span_err(span, "empty unicode escape (must have at least 1 hex digit)") + handler + .struct_span_err(span, "empty unicode escape") + .span_label(span, "this escape must have at least 1 hex digit") + .emit(); + } + EscapeError::ZeroChars => { + let msg = "empty character literal"; + handler.struct_span_err(span, msg).span_label(span, msg).emit() + } + EscapeError::LoneSlash => { + let msg = "invalid trailing slash in literal"; + handler.struct_span_err(span, msg).span_label(span, msg).emit(); } - EscapeError::ZeroChars => handler.span_err(span, "empty character literal"), - EscapeError::LoneSlash => handler.span_err(span, "invalid trailing slash in literal"), } } /// Pushes a character to a message string for error reporting -pub(crate) fn push_escaped_char(msg: &mut String, c: char) { +pub(crate) fn escaped_char(c: char) -> String { match c { '\u{20}'..='\u{7e}' => { // Don't escape \, ' or " for user-facing messages - msg.push(c); - } - _ => { - msg.extend(c.escape_default()); + c.to_string() } + _ => c.escape_default().to_string(), } } diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs index 1b26fb33370..523eb9dba35 100644 --- a/compiler/rustc_parse/src/parser/attr.rs +++ b/compiler/rustc_parse/src/parser/attr.rs @@ -306,13 +306,11 @@ impl<'a> Parser<'a> { } pub fn maybe_needs_tokens(attrs: &[ast::Attribute]) -> bool { - // One of the attributes may either itself be a macro, or apply derive macros (`derive`), + // One of the attributes may either itself be a macro, // or expand to macro attributes (`cfg_attr`). attrs.iter().any(|attr| { attr.ident().map_or(true, |ident| { - ident.name == sym::derive - || ident.name == sym::cfg_attr - || !rustc_feature::is_builtin_attr_name(ident.name) + ident.name == sym::cfg_attr || !rustc_feature::is_builtin_attr_name(ident.name) }) }) } diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs index 9d55bafd286..7493fd68505 100644 --- a/compiler/rustc_resolve/src/diagnostics.rs +++ b/compiler/rustc_resolve/src/diagnostics.rs @@ -9,6 +9,7 @@ use rustc_feature::BUILTIN_ATTRIBUTES; use rustc_hir::def::Namespace::{self, *}; use rustc_hir::def::{self, CtorKind, CtorOf, DefKind, NonMacroAttrKind}; use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use rustc_hir::PrimTy; use rustc_middle::bug; use rustc_middle::ty::{self, DefIdTree}; use rustc_session::Session; @@ -718,10 +719,9 @@ impl<'a> Resolver<'a> { } } Scope::BuiltinTypes => { - let primitive_types = &this.primitive_type_table.primitive_types; - suggestions.extend(primitive_types.iter().flat_map(|(name, prim_ty)| { + suggestions.extend(PrimTy::ALL.iter().filter_map(|prim_ty| { let res = Res::PrimTy(*prim_ty); - filter_fn(res).then_some(TypoSuggestion::from_res(*name, res)) + filter_fn(res).then_some(TypoSuggestion::from_res(prim_ty.name(), res)) })) } } @@ -1111,10 +1111,9 @@ impl<'a> Resolver<'a> { _, ) = binding.kind { - let def_id = (&*self).parent(ctor_def_id).expect("no parent for a constructor"); + let def_id = self.parent(ctor_def_id).expect("no parent for a constructor"); let fields = self.field_names.get(&def_id)?; - let first_field = fields.first()?; // Handle `struct Foo()` - return Some(fields.iter().fold(first_field.span, |acc, field| acc.to(field.span))); + return fields.iter().map(|name| name.span).reduce(Span::to); // None for `struct Foo()` } None } diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs index 9b5b793363b..cca40a793dd 100644 --- a/compiler/rustc_resolve/src/late.rs +++ b/compiler/rustc_resolve/src/late.rs @@ -20,7 +20,7 @@ use rustc_errors::DiagnosticId; use rustc_hir::def::Namespace::{self, *}; use rustc_hir::def::{self, CtorKind, DefKind, PartialRes, PerNS}; use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX}; -use rustc_hir::TraitCandidate; +use rustc_hir::{PrimTy, TraitCandidate}; use rustc_middle::{bug, span_bug}; use rustc_session::lint; use rustc_span::symbol::{kw, sym, Ident, Symbol}; @@ -1927,7 +1927,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> { self.r.trait_map.insert(id, traits); } - if self.r.primitive_type_table.primitive_types.contains_key(&path[0].ident.name) { + if PrimTy::from_name(path[0].ident.name).is_some() { let mut std_path = Vec::with_capacity(1 + path.len()); std_path.push(Segment::from_ident(Ident::with_dummy_span(sym::std))); @@ -2121,13 +2121,9 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> { // The same fallback is used when `a` resolves to nothing. PathResult::Module(ModuleOrUniformRoot::Module(_)) | PathResult::Failed { .. } if (ns == TypeNS || path.len() > 1) - && self - .r - .primitive_type_table - .primitive_types - .contains_key(&path[0].ident.name) => + && PrimTy::from_name(path[0].ident.name).is_some() => { - let prim = self.r.primitive_type_table.primitive_types[&path[0].ident.name]; + let prim = PrimTy::from_name(path[0].ident.name).unwrap(); PartialRes::with_unresolved_segments(Res::PrimTy(prim), path.len() - 1) } PathResult::Module(ModuleOrUniformRoot::Module(module)) => { diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs index 927535b72bd..d2a693a5688 100644 --- a/compiler/rustc_resolve/src/late/diagnostics.rs +++ b/compiler/rustc_resolve/src/late/diagnostics.rs @@ -1212,8 +1212,8 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> { // Add primitive types to the mix if filter_fn(Res::PrimTy(PrimTy::Bool)) { names.extend( - self.r.primitive_type_table.primitive_types.iter().map(|(name, prim_ty)| { - TypoSuggestion::from_res(*name, Res::PrimTy(*prim_ty)) + PrimTy::ALL.iter().map(|prim_ty| { + TypoSuggestion::from_res(prim_ty.name(), Res::PrimTy(*prim_ty)) }), ) } diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs index b19990e49b8..819fabdd1f1 100644 --- a/compiler/rustc_resolve/src/lib.rs +++ b/compiler/rustc_resolve/src/lib.rs @@ -25,7 +25,7 @@ use rustc_arena::{DroplessArena, TypedArena}; use rustc_ast::node_id::NodeMap; use rustc_ast::unwrap_or; use rustc_ast::visit::{self, Visitor}; -use rustc_ast::{self as ast, FloatTy, IntTy, NodeId, UintTy}; +use rustc_ast::{self as ast, NodeId}; use rustc_ast::{Crate, CRATE_NODE_ID}; use rustc_ast::{ItemKind, Path}; use rustc_ast_lowering::ResolverAstLowering; @@ -39,8 +39,7 @@ use rustc_hir::def::Namespace::*; use rustc_hir::def::{self, CtorOf, DefKind, NonMacroAttrKind, PartialRes}; use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX}; use rustc_hir::definitions::{DefKey, DefPathData, Definitions}; -use rustc_hir::PrimTy::{self, Bool, Char, Float, Int, Str, Uint}; -use rustc_hir::TraitCandidate; +use rustc_hir::{PrimTy, TraitCandidate}; use rustc_index::vec::IndexVec; use rustc_metadata::creader::{CStore, CrateLoader}; use rustc_middle::hir::exports::ExportMap; @@ -834,39 +833,6 @@ impl<'a> NameBinding<'a> { } } -/// Interns the names of the primitive types. -/// -/// All other types are defined somewhere and possibly imported, but the primitive ones need -/// special handling, since they have no place of origin. -struct PrimitiveTypeTable { - primitive_types: FxHashMap<Symbol, PrimTy>, -} - -impl PrimitiveTypeTable { - fn new() -> PrimitiveTypeTable { - let mut table = FxHashMap::default(); - - table.insert(sym::bool, Bool); - table.insert(sym::char, Char); - table.insert(sym::f32, Float(FloatTy::F32)); - table.insert(sym::f64, Float(FloatTy::F64)); - table.insert(sym::isize, Int(IntTy::Isize)); - table.insert(sym::i8, Int(IntTy::I8)); - table.insert(sym::i16, Int(IntTy::I16)); - table.insert(sym::i32, Int(IntTy::I32)); - table.insert(sym::i64, Int(IntTy::I64)); - table.insert(sym::i128, Int(IntTy::I128)); - table.insert(sym::str, Str); - table.insert(sym::usize, Uint(UintTy::Usize)); - table.insert(sym::u8, Uint(UintTy::U8)); - table.insert(sym::u16, Uint(UintTy::U16)); - table.insert(sym::u32, Uint(UintTy::U32)); - table.insert(sym::u64, Uint(UintTy::U64)); - table.insert(sym::u128, Uint(UintTy::U128)); - Self { primitive_types: table } - } -} - #[derive(Debug, Default, Clone)] pub struct ExternPreludeEntry<'a> { extern_crate_item: Option<&'a NameBinding<'a>>, @@ -912,9 +878,6 @@ pub struct Resolver<'a> { /// "self-confirming" import resolutions during import validation. unusable_binding: Option<&'a NameBinding<'a>>, - /// The idents for the primitive types. - primitive_type_table: PrimitiveTypeTable, - /// Resolutions for nodes that have a single resolution. partial_res_map: NodeMap<PartialRes>, /// Resolutions for import nodes, which have multiple resolutions in different namespaces. @@ -1004,6 +967,8 @@ pub struct Resolver<'a> { output_macro_rules_scopes: FxHashMap<ExpnId, MacroRulesScopeRef<'a>>, /// Helper attributes that are in scope for the given expansion. helper_attrs: FxHashMap<ExpnId, Vec<Ident>>, + /// Resolutions for paths inside the `#[derive(...)]` attribute with the given `ExpnId`. + derive_resolutions: FxHashMap<ExpnId, Vec<(Lrc<SyntaxExtension>, ast::Path)>>, /// Avoid duplicated errors for "name already defined". name_already_seen: FxHashMap<Symbol, Span>, @@ -1284,8 +1249,6 @@ impl<'a> Resolver<'a> { last_import_segment: false, unusable_binding: None, - primitive_type_table: PrimitiveTypeTable::new(), - partial_res_map: Default::default(), import_res_map: Default::default(), label_res_map: Default::default(), @@ -1334,6 +1297,7 @@ impl<'a> Resolver<'a> { invocation_parent_scopes: Default::default(), output_macro_rules_scopes: Default::default(), helper_attrs: Default::default(), + derive_resolutions: Default::default(), local_macro_def_scopes: FxHashMap::default(), name_already_seen: FxHashMap::default(), potentially_unused_imports: Vec::new(), @@ -1994,9 +1958,9 @@ impl<'a> Resolver<'a> { } if ns == TypeNS { - if let Some(prim_ty) = self.primitive_type_table.primitive_types.get(&ident.name) { + if let Some(prim_ty) = PrimTy::from_name(ident.name) { let binding = - (Res::PrimTy(*prim_ty), ty::Visibility::Public, DUMMY_SP, ExpnId::root()) + (Res::PrimTy(prim_ty), ty::Visibility::Public, DUMMY_SP, ExpnId::root()) .to_name_binding(self.arenas); return Some(LexicalScopeBinding::Item(binding)); } diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs index d0adee2429d..f7010ca94bd 100644 --- a/compiler/rustc_resolve/src/macros.rs +++ b/compiler/rustc_resolve/src/macros.rs @@ -14,16 +14,17 @@ use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::ptr_key::PtrKey; use rustc_data_structures::sync::Lrc; use rustc_errors::struct_span_err; -use rustc_expand::base::{Indeterminate, InvocationRes, ResolverExpand}; -use rustc_expand::base::{SyntaxExtension, SyntaxExtensionKind}; +use rustc_expand::base::{Indeterminate, ResolverExpand, SyntaxExtension, SyntaxExtensionKind}; use rustc_expand::compile_declarative_macro; use rustc_expand::expand::{AstFragment, Invocation, InvocationKind}; use rustc_feature::is_builtin_attr_name; use rustc_hir::def::{self, DefKind, NonMacroAttrKind}; use rustc_hir::def_id; +use rustc_hir::PrimTy; use rustc_middle::middle::stability; use rustc_middle::ty; -use rustc_session::lint::builtin::{SOFT_UNSTABLE, UNUSED_MACROS}; +use rustc_session::lint::builtin::{LEGACY_DERIVE_HELPERS, SOFT_UNSTABLE, UNUSED_MACROS}; +use rustc_session::lint::BuiltinLintDiagnostics; use rustc_session::parse::feature_err; use rustc_session::Session; use rustc_span::edition::Edition; @@ -226,7 +227,7 @@ impl<'a> ResolverExpand for Resolver<'a> { invoc: &Invocation, eager_expansion_root: ExpnId, force: bool, - ) -> Result<InvocationRes, Indeterminate> { + ) -> Result<Lrc<SyntaxExtension>, Indeterminate> { let invoc_id = invoc.expansion_data.id; let parent_scope = match self.invocation_parent_scopes.get(&invoc_id) { Some(parent_scope) => *parent_scope, @@ -243,65 +244,15 @@ impl<'a> ResolverExpand for Resolver<'a> { } }; - let (path, kind, inner_attr, derives, after_derive) = match invoc.kind { - InvocationKind::Attr { ref attr, ref derives, after_derive, .. } => ( + let (path, kind, inner_attr, derives) = match invoc.kind { + InvocationKind::Attr { ref attr, ref derives, .. } => ( &attr.get_normal_item().path, MacroKind::Attr, attr.style == ast::AttrStyle::Inner, self.arenas.alloc_ast_paths(derives), - after_derive, ), - InvocationKind::Bang { ref mac, .. } => { - (&mac.path, MacroKind::Bang, false, &[][..], false) - } - InvocationKind::Derive { ref path, .. } => { - (path, MacroKind::Derive, false, &[][..], false) - } - InvocationKind::DeriveContainer { ref derives, .. } => { - // Block expansion of the container until we resolve all derives in it. - // This is required for two reasons: - // - Derive helper attributes are in scope for the item to which the `#[derive]` - // is applied, so they have to be produced by the container's expansion rather - // than by individual derives. - // - Derives in the container need to know whether one of them is a built-in `Copy`. - // FIXME: Try to avoid repeated resolutions for derives here and in expansion. - let mut exts = Vec::new(); - let mut helper_attrs = Vec::new(); - for path in derives { - exts.push( - match self.resolve_macro_path( - path, - Some(MacroKind::Derive), - &parent_scope, - true, - force, - ) { - Ok((Some(ext), _)) => { - let span = path - .segments - .last() - .unwrap() - .ident - .span - .normalize_to_macros_2_0(); - helper_attrs.extend( - ext.helper_attrs.iter().map(|name| Ident::new(*name, span)), - ); - if ext.builtin_name == Some(sym::Copy) { - self.containers_deriving_copy.insert(invoc_id); - } - ext - } - Ok(_) | Err(Determinacy::Determined) => { - self.dummy_ext(MacroKind::Derive) - } - Err(Determinacy::Undetermined) => return Err(Indeterminate), - }, - ) - } - self.helper_attrs.insert(invoc_id, helper_attrs); - return Ok(InvocationRes::DeriveContainer(exts)); - } + InvocationKind::Bang { ref mac, .. } => (&mac.path, MacroKind::Bang, false, &[][..]), + InvocationKind::Derive { ref path, .. } => (path, MacroKind::Derive, false, &[][..]), }; // Derives are not included when `invocations` are collected, so we have to add them here. @@ -327,14 +278,41 @@ impl<'a> ResolverExpand for Resolver<'a> { )); if let Res::Def(_, _) = res { - if after_derive { - self.session.span_err(span, "macro attributes must be placed before `#[derive]`"); - } let normal_module_def_id = self.macro_def_scope(invoc_id).nearest_parent_mod; self.definitions.add_parent_module_of_macro_def(invoc_id, normal_module_def_id); + + // Gate macro attributes in `#[derive]` output. + if !self.session.features_untracked().macro_attributes_in_derive_output + && kind == MacroKind::Attr + && ext.builtin_name != Some(sym::derive) + { + let mut expn_id = parent_scope.expansion; + loop { + // Helper attr table is a quick way to determine whether the attr is `derive`. + if self.helper_attrs.contains_key(&expn_id) { + feature_err( + &self.session.parse_sess, + sym::macro_attributes_in_derive_output, + path.span, + "macro attributes in `#[derive]` output are unstable", + ) + .emit(); + break; + } else { + let expn_data = expn_id.expn_data(); + match expn_data.kind { + ExpnKind::Root + | ExpnKind::Macro(MacroKind::Bang | MacroKind::Derive, _) => { + break; + } + _ => expn_id = expn_data.parent, + } + } + } + } } - Ok(InvocationRes::Single(ext)) + Ok(ext) } fn check_unused_macros(&mut self) { @@ -343,7 +321,7 @@ impl<'a> ResolverExpand for Resolver<'a> { } } - fn lint_node_id(&mut self, expn_id: ExpnId) -> NodeId { + fn lint_node_id(&self, expn_id: ExpnId) -> NodeId { // FIXME - make this more precise. This currently returns the NodeId of the // nearest closing item - we should try to return the closest parent of the ExpnId self.invocation_parents @@ -355,6 +333,63 @@ impl<'a> ResolverExpand for Resolver<'a> { self.containers_deriving_copy.contains(&expn_id) } + fn resolve_derives( + &mut self, + expn_id: ExpnId, + derives: Vec<ast::Path>, + force: bool, + ) -> Result<(), Indeterminate> { + // Block expansion of the container until we resolve all derives in it. + // This is required for two reasons: + // - Derive helper attributes are in scope for the item to which the `#[derive]` + // is applied, so they have to be produced by the container's expansion rather + // than by individual derives. + // - Derives in the container need to know whether one of them is a built-in `Copy`. + // FIXME: Try to cache intermediate results to avoid resolving same derives multiple times. + let parent_scope = self.invocation_parent_scopes[&expn_id]; + let mut exts = Vec::new(); + let mut helper_attrs = Vec::new(); + let mut has_derive_copy = false; + for path in derives { + exts.push(( + match self.resolve_macro_path( + &path, + Some(MacroKind::Derive), + &parent_scope, + true, + force, + ) { + Ok((Some(ext), _)) => { + let span = + path.segments.last().unwrap().ident.span.normalize_to_macros_2_0(); + helper_attrs + .extend(ext.helper_attrs.iter().map(|name| Ident::new(*name, span))); + has_derive_copy |= ext.builtin_name == Some(sym::Copy); + ext + } + Ok(_) | Err(Determinacy::Determined) => self.dummy_ext(MacroKind::Derive), + Err(Determinacy::Undetermined) => return Err(Indeterminate), + }, + path, + )) + } + self.derive_resolutions.insert(expn_id, exts); + self.helper_attrs.insert(expn_id, helper_attrs); + // Mark this derive as having `Copy` either if it has `Copy` itself or if its parent derive + // has `Copy`, to support cases like `#[derive(Clone, Copy)] #[derive(Debug)]`. + if has_derive_copy || self.has_derive_copy(parent_scope.expansion) { + self.containers_deriving_copy.insert(expn_id); + } + Ok(()) + } + + fn take_derive_resolutions( + &mut self, + expn_id: ExpnId, + ) -> Option<Vec<(Lrc<SyntaxExtension>, ast::Path)>> { + self.derive_resolutions.remove(&expn_id) + } + // The function that implements the resolution logic of `#[cfg_accessible(path)]`. // Returns true if the path can certainly be resolved in one of three namespaces, // returns false if the path certainly cannot be resolved in any of the three namespaces. @@ -796,12 +831,10 @@ impl<'a> Resolver<'a> { } result } - Scope::BuiltinTypes => { - match this.primitive_type_table.primitive_types.get(&ident.name).cloned() { - Some(prim_ty) => ok(Res::PrimTy(prim_ty), DUMMY_SP, this.arenas), - None => Err(Determinacy::Determined), - } - } + Scope::BuiltinTypes => match PrimTy::from_name(ident.name) { + Some(prim_ty) => ok(Res::PrimTy(prim_ty), DUMMY_SP, this.arenas), + None => Err(Determinacy::Determined), + }, }; match result { @@ -819,6 +852,8 @@ impl<'a> Resolver<'a> { let is_builtin = |res| { matches!(res, Res::NonMacroAttr(NonMacroAttrKind::Builtin(..))) }; + let derive_helper = + Res::NonMacroAttr(NonMacroAttrKind::DeriveHelper); let derive_helper_compat = Res::NonMacroAttr(NonMacroAttrKind::DeriveHelperCompat); @@ -827,7 +862,7 @@ impl<'a> Resolver<'a> { } else if is_builtin(innermost_res) || is_builtin(res) { Some(AmbiguityKind::BuiltinAttr) } else if innermost_res == derive_helper_compat - || res == derive_helper_compat + || res == derive_helper_compat && innermost_res != derive_helper { Some(AmbiguityKind::DeriveHelper) } else if innermost_flags.contains(Flags::MACRO_RULES) @@ -993,6 +1028,15 @@ impl<'a> Resolver<'a> { let res = binding.res(); let seg = Segment::from_ident(ident); check_consistency(self, &[seg], ident.span, kind, initial_res, res); + if res == Res::NonMacroAttr(NonMacroAttrKind::DeriveHelperCompat) { + self.lint_buffer.buffer_lint_with_diagnostic( + LEGACY_DERIVE_HELPERS, + self.lint_node_id(parent_scope.expansion), + ident.span, + "derive helper attribute is used before it is introduced", + BuiltinLintDiagnostics::LegacyDeriveHelpers(binding.span), + ); + } } Err(..) => { let expected = kind.descr_expected(); @@ -1079,7 +1123,7 @@ impl<'a> Resolver<'a> { crate fn check_reserved_macro_name(&mut self, ident: Ident, res: Res) { // Reserve some names that are not quite covered by the general check // performed on `Resolver::builtin_attrs`. - if ident.name == sym::cfg || ident.name == sym::cfg_attr || ident.name == sym::derive { + if ident.name == sym::cfg || ident.name == sym::cfg_attr { let macro_kind = self.get_macro(res).map(|ext| ext.macro_kind()); if macro_kind.is_some() && sub_namespace_match(macro_kind, Some(MacroKind::Attr)) { self.session.span_err( diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 9d73c3b4424..e9ea0ab6f98 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -15,6 +15,8 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_target::abi::{Align, TargetDataLayout}; use rustc_target::spec::{SplitDebuginfo, Target, TargetTriple}; +use rustc_serialize::json; + use crate::parse::CrateConfig; use rustc_feature::UnstableFeatures; use rustc_span::edition::{Edition, DEFAULT_EDITION, EDITION_NAME_LIST}; @@ -408,6 +410,9 @@ impl OutputTypes { #[derive(Clone)] pub struct Externs(BTreeMap<String, ExternEntry>); +#[derive(Clone)] +pub struct ExternDepSpecs(BTreeMap<String, ExternDepSpec>); + #[derive(Clone, Debug)] pub struct ExternEntry { pub location: ExternLocation, @@ -439,6 +444,27 @@ pub enum ExternLocation { ExactPaths(BTreeSet<CanonicalizedPath>), } +/// Supplied source location of a dependency - for example in a build specification +/// file like Cargo.toml. We support several syntaxes: if it makes sense to reference +/// a file and line, then the build system can specify that. On the other hand, it may +/// make more sense to have an arbitrary raw string. +#[derive(Clone, PartialEq)] +pub enum ExternDepSpec { + /// Raw string + Raw(String), + /// Raw data in json format + Json(json::Json), +} + +impl<'a> From<&'a ExternDepSpec> for rustc_lint_defs::ExternDepSpec { + fn from(from: &'a ExternDepSpec) -> Self { + match from { + ExternDepSpec::Raw(s) => rustc_lint_defs::ExternDepSpec::Raw(s.clone()), + ExternDepSpec::Json(json) => rustc_lint_defs::ExternDepSpec::Json(json.clone()), + } + } +} + impl Externs { pub fn new(data: BTreeMap<String, ExternEntry>) -> Externs { Externs(data) @@ -466,6 +492,25 @@ impl ExternEntry { } } +impl ExternDepSpecs { + pub fn new(data: BTreeMap<String, ExternDepSpec>) -> ExternDepSpecs { + ExternDepSpecs(data) + } + + pub fn get(&self, key: &str) -> Option<&ExternDepSpec> { + self.0.get(key) + } +} + +impl fmt::Display for ExternDepSpec { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + ExternDepSpec::Raw(raw) => fmt.write_str(raw), + ExternDepSpec::Json(json) => json::as_json(json).fmt(fmt), + } + } +} + #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub enum PrintRequest { FileNames, @@ -679,6 +724,7 @@ impl Default for Options { cg: basic_codegen_options(), error_format: ErrorOutputType::default(), externs: Externs(BTreeMap::new()), + extern_dep_specs: ExternDepSpecs(BTreeMap::new()), crate_name: None, alt_std_name: None, libs: Vec::new(), @@ -1105,6 +1151,12 @@ pub fn rustc_optgroups() -> Vec<RustcOptGroup> { "Specify where an external rust library is located", "NAME[=PATH]", ), + opt::multi_s( + "", + "extern-location", + "Location where an external crate dependency is specified", + "NAME=LOCATION", + ), opt::opt_s("", "sysroot", "Override the system root", "PATH"), opt::multi("Z", "", "Set internal debugging options", "FLAG"), opt::opt_s( @@ -1727,6 +1779,68 @@ pub fn parse_externs( Externs(externs) } +fn parse_extern_dep_specs( + matches: &getopts::Matches, + debugging_opts: &DebuggingOptions, + error_format: ErrorOutputType, +) -> ExternDepSpecs { + let is_unstable_enabled = debugging_opts.unstable_options; + let mut map = BTreeMap::new(); + + for arg in matches.opt_strs("extern-location") { + if !is_unstable_enabled { + early_error( + error_format, + "`--extern-location` option is unstable: set `-Z unstable-options`", + ); + } + + let mut parts = arg.splitn(2, '='); + let name = parts.next().unwrap_or_else(|| { + early_error(error_format, "`--extern-location` value must not be empty") + }); + let loc = parts.next().unwrap_or_else(|| { + early_error( + error_format, + &format!("`--extern-location`: specify location for extern crate `{}`", name), + ) + }); + + let locparts: Vec<_> = loc.split(":").collect(); + let spec = match &locparts[..] { + ["raw", ..] => { + // Don't want `:` split string + let raw = loc.splitn(2, ':').nth(1).unwrap_or_else(|| { + early_error(error_format, "`--extern-location`: missing `raw` location") + }); + ExternDepSpec::Raw(raw.to_string()) + } + ["json", ..] => { + // Don't want `:` split string + let raw = loc.splitn(2, ':').nth(1).unwrap_or_else(|| { + early_error(error_format, "`--extern-location`: missing `json` location") + }); + let json = json::from_str(raw).unwrap_or_else(|_| { + early_error( + error_format, + &format!("`--extern-location`: malformed json location `{}`", raw), + ) + }); + ExternDepSpec::Json(json) + } + [bad, ..] => early_error( + error_format, + &format!("unknown location type `{}`: use `raw` or `json`", bad), + ), + [] => early_error(error_format, "missing location specification"), + }; + + map.insert(name.to_string(), spec); + } + + ExternDepSpecs::new(map) +} + fn parse_remap_path_prefix( matches: &getopts::Matches, error_format: ErrorOutputType, @@ -1888,6 +2002,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } let externs = parse_externs(matches, &debugging_opts, error_format); + let extern_dep_specs = parse_extern_dep_specs(matches, &debugging_opts, error_format); let crate_name = matches.opt_str("crate-name"); @@ -1924,6 +2039,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { error_format, externs, unstable_features: UnstableFeatures::from_environment(crate_name.as_deref()), + extern_dep_specs, crate_name, alt_std_name: None, libs, diff --git a/compiler/rustc_session/src/filesearch.rs b/compiler/rustc_session/src/filesearch.rs index 3a757e5f007..47f14fa6b7a 100644 --- a/compiler/rustc_session/src/filesearch.rs +++ b/compiler/rustc_session/src/filesearch.rs @@ -113,6 +113,8 @@ pub fn make_target_lib_path(sysroot: &Path, target_triple: &str) -> PathBuf { sysroot.join(&relative_target_lib_path(sysroot, target_triple)) } +// This function checks if sysroot is found using env::args().next(), and if it +// is not found, uses env::current_exe() to imply sysroot. pub fn get_or_default_sysroot() -> PathBuf { // Follow symlinks. If the resolved path is relative, make it absolute. fn canonicalize(path: PathBuf) -> PathBuf { @@ -123,15 +125,51 @@ pub fn get_or_default_sysroot() -> PathBuf { fix_windows_verbatim_for_gcc(&path) } - match env::current_exe() { - Ok(exe) => { - let mut p = canonicalize(exe); - p.pop(); - p.pop(); - p + // Use env::current_exe() to get the path of the executable following + // symlinks/canonicalizing components. + fn from_current_exe() -> PathBuf { + match env::current_exe() { + Ok(exe) => { + let mut p = canonicalize(exe); + p.pop(); + p.pop(); + p + } + Err(e) => panic!("failed to get current_exe: {}", e), + } + } + + // Use env::args().next() to get the path of the executable without + // following symlinks/canonicalizing any component. This makes the rustc + // binary able to locate Rust libraries in systems using content-addressable + // storage (CAS). + fn from_env_args_next() -> Option<PathBuf> { + match env::args_os().next() { + Some(first_arg) => { + let mut p = PathBuf::from(first_arg); + + // Check if sysroot is found using env::args().next() only if the rustc in argv[0] + // is a symlink (see #79253). We might want to change/remove it to conform with + // https://www.gnu.org/prep/standards/standards.html#Finding-Program-Files in the + // future. + if fs::read_link(&p).is_err() { + // Path is not a symbolic link or does not exist. + return None; + } + + p.pop(); + p.pop(); + let mut libdir = PathBuf::from(&p); + libdir.push(find_libdir(&p).as_ref()); + if libdir.exists() { Some(p) } else { None } + } + None => None, } - Err(e) => panic!("failed to get current_exe: {}", e), } + + // Check if sysroot is found using env::args().next(), and if is not found, + // use env::current_exe() to imply sysroot. + from_env_args_next().unwrap_or(from_current_exe()) } // The name of the directory rustc expects libraries to be located. diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs index 779e0421636..f78df8a7e29 100644 --- a/compiler/rustc_session/src/options.rs +++ b/compiler/rustc_session/src/options.rs @@ -112,6 +112,7 @@ top_level_options!( borrowck_mode: BorrowckMode [UNTRACKED], cg: CodegenOptions [TRACKED], externs: Externs [UNTRACKED], + extern_dep_specs: ExternDepSpecs [UNTRACKED], crate_name: Option<String> [TRACKED], // An optional name to use as the crate for std during std injection, // written `extern crate name as std`. Defaults to `std`. Used by diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs index f3d876a5770..79c5c7f110c 100644 --- a/compiler/rustc_span/src/lib.rs +++ b/compiler/rustc_span/src/lib.rs @@ -22,6 +22,7 @@ #![feature(nll)] #![feature(min_specialization)] #![feature(option_expect_none)] +#![feature(str_split_once)] #[macro_use] extern crate rustc_macros; diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs index 2b429372dcf..298c995b166 100644 --- a/compiler/rustc_span/src/source_map.rs +++ b/compiler/rustc_span/src/source_map.rs @@ -539,7 +539,7 @@ impl SourceMap { pub fn is_line_before_span_empty(&self, sp: Span) -> bool { match self.span_to_prev_source(sp) { - Ok(s) => s.split('\n').last().map_or(false, |l| l.trim_start().is_empty()), + Ok(s) => s.rsplit_once('\n').unwrap_or(("", &s)).1.trim_start().is_empty(), Err(_) => false, } } @@ -632,10 +632,11 @@ impl SourceMap { pub fn span_to_margin(&self, sp: Span) -> Option<usize> { match self.span_to_prev_source(sp) { Err(_) => None, - Ok(source) => source - .split('\n') - .last() - .map(|last_line| last_line.len() - last_line.trim_start().len()), + Ok(source) => { + let last_line = source.rsplit_once('\n').unwrap_or(("", &source)).1; + + Some(last_line.len() - last_line.trim_start().len()) + } } } @@ -651,7 +652,7 @@ impl SourceMap { pub fn span_extend_to_prev_char(&self, sp: Span, c: char, accept_newlines: bool) -> Span { if let Ok(prev_source) = self.span_to_prev_source(sp) { let prev_source = prev_source.rsplit(c).next().unwrap_or(""); - if !prev_source.is_empty() && (!prev_source.contains('\n') || accept_newlines) { + if !prev_source.is_empty() && (accept_newlines || !prev_source.contains('\n')) { return sp.with_lo(BytePos(sp.lo().0 - prev_source.len() as u32)); } } @@ -673,7 +674,7 @@ impl SourceMap { let prev_source = prev_source.rsplit(&pat).next().unwrap_or("").trim_start(); if prev_source.is_empty() && sp.lo().0 != 0 { return sp.with_lo(BytePos(sp.lo().0 - 1)); - } else if !prev_source.contains('\n') || accept_newlines { + } else if accept_newlines || !prev_source.contains('\n') { return sp.with_lo(BytePos(sp.lo().0 - prev_source.len() as u32)); } } @@ -693,7 +694,7 @@ impl SourceMap { pub fn span_extend_to_next_char(&self, sp: Span, c: char, accept_newlines: bool) -> Span { if let Ok(next_source) = self.span_to_next_source(sp) { let next_source = next_source.split(c).next().unwrap_or(""); - if !next_source.is_empty() && (!next_source.contains('\n') || accept_newlines) { + if !next_source.is_empty() && (accept_newlines || !next_source.contains('\n')) { return sp.with_hi(BytePos(sp.hi().0 + next_source.len() as u32)); } } diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index df23b4006b3..20e4f7262ac 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -679,6 +679,7 @@ symbols! { loop_break_value, lt, macro_at_most_once_rep, + macro_attributes_in_derive_output, macro_escape, macro_export, macro_lifetime_matcher, @@ -907,6 +908,7 @@ symbols! { register_attr, register_tool, relaxed_adts, + relaxed_struct_unsize, rem, rem_assign, repr, diff --git a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs index 89820bb1417..b1ac02d9fed 100644 --- a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs +++ b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs @@ -117,7 +117,7 @@ pub fn is_const_evaluatable<'cx, 'tcx>( { err.span_help( tcx.def_span(def.did), - &format!("try adding a `where` bound using this expression: where [u8; {}]: Sized", snippet), + &format!("try adding a `where` bound using this expression: `where [u8; {}]: Sized`", snippet), ); } else { err.span_help( diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs index d3b3403ac3e..756281450d7 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs @@ -1780,7 +1780,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { multispan.push_span_label( sp, format!( - "...if indirection was used here: `Box<{}>`", + "...if indirection were used here: `Box<{}>`", param.name.ident(), ), ); diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 21828006164..34bd332951c 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -1103,7 +1103,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { // This is currently not possible to trigger because E0038 takes precedence, but // leave it in for completeness in case anything changes in an earlier stage. err.note(&format!( - "if trait `{}` was object safe, you could return a trait object", + "if trait `{}` were object-safe, you could return a trait object", trait_obj, )); } diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs index 3852005ee3f..e155f0366e1 100644 --- a/compiler/rustc_trait_selection/src/traits/object_safety.rs +++ b/compiler/rustc_trait_selection/src/traits/object_safety.rs @@ -257,13 +257,11 @@ fn predicates_reference_self( } fn bounds_reference_self(tcx: TyCtxt<'_>, trait_def_id: DefId) -> SmallVec<[Span; 1]> { - let trait_ref = ty::Binder::dummy(ty::TraitRef::identity(tcx, trait_def_id)); tcx.associated_items(trait_def_id) .in_definition_order() .filter(|item| item.kind == ty::AssocKind::Type) .flat_map(|item| tcx.explicit_item_bounds(item.def_id)) - .map(|&(predicate, sp)| (predicate.subst_supertrait(tcx, &trait_ref), sp)) - .filter_map(|predicate| predicate_references_self(tcx, predicate)) + .filter_map(|pred_span| predicate_references_self(tcx, *pred_span)) .collect() } diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs index 3015188fd44..ed3e117fcfa 100644 --- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs +++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs @@ -823,33 +823,59 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }, }; + // FIXME(eddyb) cache this (including computing `unsizing_params`) + // by putting it in a query; it would only need the `DefId` as it + // looks at declared field types, not anything substituted. + // The last field of the structure has to exist and contain type/const parameters. let (tail_field, prefix_fields) = def.non_enum_variant().fields.split_last().ok_or(Unimplemented)?; let tail_field_ty = tcx.type_of(tail_field.did); let mut unsizing_params = GrowableBitSet::new_empty(); - let mut found = false; - for arg in tail_field_ty.walk() { - if let Some(i) = maybe_unsizing_param_idx(arg) { - unsizing_params.insert(i); - found = true; + if tcx.features().relaxed_struct_unsize { + for arg in tail_field_ty.walk() { + if let Some(i) = maybe_unsizing_param_idx(arg) { + unsizing_params.insert(i); + } } - } - if !found { - return Err(Unimplemented); - } - // Ensure none of the other fields mention the parameters used - // in unsizing. - // FIXME(eddyb) cache this (including computing `unsizing_params`) - // by putting it in a query; it would only need the `DefId` as it - // looks at declared field types, not anything substituted. - for field in prefix_fields { - for arg in tcx.type_of(field.did).walk() { + // Ensure none of the other fields mention the parameters used + // in unsizing. + for field in prefix_fields { + for arg in tcx.type_of(field.did).walk() { + if let Some(i) = maybe_unsizing_param_idx(arg) { + unsizing_params.remove(i); + } + } + } + + if unsizing_params.is_empty() { + return Err(Unimplemented); + } + } else { + let mut found = false; + for arg in tail_field_ty.walk() { if let Some(i) = maybe_unsizing_param_idx(arg) { - if unsizing_params.contains(i) { - return Err(Unimplemented); + unsizing_params.insert(i); + found = true; + } + } + if !found { + return Err(Unimplemented); + } + + // Ensure none of the other fields mention the parameters used + // in unsizing. + // FIXME(eddyb) cache this (including computing `unsizing_params`) + // by putting it in a query; it would only need the `DefId` as it + // looks at declared field types, not anything substituted. + for field in prefix_fields { + for arg in tcx.type_of(field.did).walk() { + if let Some(i) = maybe_unsizing_param_idx(arg) { + if unsizing_params.contains(i) { + return Err(Unimplemented); + } } } } diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index 437813ea41b..5659345f0ff 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -112,12 +112,15 @@ pub enum SizedByDefault { No, } +#[derive(Debug)] struct ConvertedBinding<'a, 'tcx> { item_name: Ident, kind: ConvertedBindingKind<'a, 'tcx>, + gen_args: &'a GenericArgs<'a>, span: Span, } +#[derive(Debug)] enum ConvertedBindingKind<'a, 'tcx> { Equality(Ty<'tcx>), Constraint(&'a [hir::GenericBound<'a>]), @@ -323,6 +326,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { let tcx = self.tcx(); let generics = tcx.generics_of(def_id); + debug!("generics: {:?}", generics); if generics.has_self { if generics.parent.is_some() { @@ -557,7 +561,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { ConvertedBindingKind::Constraint(bounds) } }; - ConvertedBinding { item_name: binding.ident, kind, span: binding.span } + ConvertedBinding { + item_name: binding.ident, + kind, + gen_args: binding.gen_args, + span: binding.span, + } }) .collect(); @@ -918,60 +927,27 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { dup_bindings: &mut FxHashMap<DefId, Span>, path_span: Span, ) -> Result<(), ErrorReported> { - let tcx = self.tcx(); - - if !speculative { - // Given something like `U: SomeTrait<T = X>`, we want to produce a - // predicate like `<U as SomeTrait>::T = X`. This is somewhat - // subtle in the event that `T` is defined in a supertrait of - // `SomeTrait`, because in that case we need to upcast. - // - // That is, consider this case: - // - // ``` - // trait SubTrait: SuperTrait<i32> { } - // trait SuperTrait<A> { type T; } - // - // ... B: SubTrait<T = foo> ... - // ``` - // - // We want to produce `<B as SuperTrait<i32>>::T == foo`. - - // Find any late-bound regions declared in `ty` that are not - // declared in the trait-ref. These are not well-formed. - // - // Example: - // - // for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad - // for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok - if let ConvertedBindingKind::Equality(ty) = binding.kind { - let late_bound_in_trait_ref = - tcx.collect_constrained_late_bound_regions(&trait_ref); - let late_bound_in_ty = - tcx.collect_referenced_late_bound_regions(&ty::Binder::bind(ty)); - debug!("late_bound_in_trait_ref = {:?}", late_bound_in_trait_ref); - debug!("late_bound_in_ty = {:?}", late_bound_in_ty); + // Given something like `U: SomeTrait<T = X>`, we want to produce a + // predicate like `<U as SomeTrait>::T = X`. This is somewhat + // subtle in the event that `T` is defined in a supertrait of + // `SomeTrait`, because in that case we need to upcast. + // + // That is, consider this case: + // + // ``` + // trait SubTrait: SuperTrait<i32> { } + // trait SuperTrait<A> { type T; } + // + // ... B: SubTrait<T = foo> ... + // ``` + // + // We want to produce `<B as SuperTrait<i32>>::T == foo`. - // FIXME: point at the type params that don't have appropriate lifetimes: - // struct S1<F: for<'a> Fn(&i32, &i32) -> &'a i32>(F); - // ---- ---- ^^^^^^^ - self.validate_late_bound_regions( - late_bound_in_trait_ref, - late_bound_in_ty, - |br_name| { - struct_span_err!( - tcx.sess, - binding.span, - E0582, - "binding for associated type `{}` references {}, \ - which does not appear in the trait input types", - binding.item_name, - br_name - ) - }, - ); - } - } + debug!( + "add_predicates_for_ast_type_binding(hir_ref_id {:?}, trait_ref {:?}, binding {:?}, bounds {:?}", + hir_ref_id, trait_ref, binding, bounds + ); + let tcx = self.tcx(); let candidate = if self.trait_defines_associated_type_named(trait_ref.def_id(), binding.item_name) { @@ -1030,6 +1006,72 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { .or_insert(binding.span); } + // Include substitutions for generic parameters of associated types + let projection_ty = candidate.map_bound(|trait_ref| { + let item_segment = hir::PathSegment { + ident: assoc_ty.ident, + hir_id: None, + res: None, + args: Some(binding.gen_args), + infer_args: false, + }; + + let substs_trait_ref_and_assoc_item = self.create_substs_for_associated_item( + tcx, + path_span, + assoc_ty.def_id, + &item_segment, + trait_ref.substs, + ); + + debug!( + "add_predicates_for_ast_type_binding: substs for trait-ref and assoc_item: {:?}", + substs_trait_ref_and_assoc_item + ); + + ty::ProjectionTy { + item_def_id: assoc_ty.def_id, + substs: substs_trait_ref_and_assoc_item, + } + }); + + if !speculative { + // Find any late-bound regions declared in `ty` that are not + // declared in the trait-ref or assoc_ty. These are not well-formed. + // + // Example: + // + // for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad + // for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok + if let ConvertedBindingKind::Equality(ty) = binding.kind { + let late_bound_in_trait_ref = + tcx.collect_constrained_late_bound_regions(&projection_ty); + let late_bound_in_ty = + tcx.collect_referenced_late_bound_regions(&ty::Binder::bind(ty)); + debug!("late_bound_in_trait_ref = {:?}", late_bound_in_trait_ref); + debug!("late_bound_in_ty = {:?}", late_bound_in_ty); + + // FIXME: point at the type params that don't have appropriate lifetimes: + // struct S1<F: for<'a> Fn(&i32, &i32) -> &'a i32>(F); + // ---- ---- ^^^^^^^ + self.validate_late_bound_regions( + late_bound_in_trait_ref, + late_bound_in_ty, + |br_name| { + struct_span_err!( + tcx.sess, + binding.span, + E0582, + "binding for associated type `{}` references {}, \ + which does not appear in the trait input types", + binding.item_name, + br_name + ) + }, + ); + } + } + match binding.kind { ConvertedBindingKind::Equality(ref ty) => { // "Desugar" a constraint like `T: Iterator<Item = u32>` this to @@ -1037,13 +1079,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { // // `<T as Iterator>::Item = u32` bounds.projection_bounds.push(( - candidate.map_bound(|trait_ref| ty::ProjectionPredicate { - projection_ty: ty::ProjectionTy::from_ref_and_name( - tcx, - trait_ref, - binding.item_name, - ), - ty, + projection_ty.map_bound(|projection_ty| { + debug!( + "add_predicates_for_ast_type_binding: projection_ty {:?}, substs: {:?}", + projection_ty, projection_ty.substs + ); + ty::ProjectionPredicate { projection_ty, ty } }), binding.span, )); @@ -1055,7 +1096,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { // // Calling `skip_binder` is okay, because `add_bounds` expects the `param_ty` // parameter to have a skipped binder. - let param_ty = tcx.mk_projection(assoc_ty.def_id, candidate.skip_binder().substs); + let param_ty = + tcx.mk_projection(assoc_ty.def_id, projection_ty.skip_binder().substs); self.add_bounds(param_ty, ast_bounds, bounds); } } diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs index 8e2b0bfd662..5f27355f0ba 100644 --- a/compiler/rustc_typeck/src/check/check.rs +++ b/compiler/rustc_typeck/src/check/check.rs @@ -12,6 +12,7 @@ use rustc_hir::{ItemKind, Node}; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt}; use rustc_middle::ty::fold::TypeFoldable; +use rustc_middle::ty::layout::MAX_SIMD_LANES; use rustc_middle::ty::subst::GenericArgKind; use rustc_middle::ty::util::{Discr, IntTypeExt, Representability}; use rustc_middle::ty::{self, ParamEnv, RegionKind, ToPredicate, Ty, TyCtxt}; @@ -1134,6 +1135,38 @@ pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) { .emit(); return; } + + let len = if let ty::Array(_ty, c) = e.kind() { + c.try_eval_usize(tcx, tcx.param_env(def.did)) + } else { + Some(fields.len() as u64) + }; + if let Some(len) = len { + if len == 0 { + struct_span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty").emit(); + return; + } else if !len.is_power_of_two() { + struct_span_err!( + tcx.sess, + sp, + E0075, + "SIMD vector length must be a power of two" + ) + .emit(); + return; + } else if len > MAX_SIMD_LANES { + struct_span_err!( + tcx.sess, + sp, + E0075, + "SIMD vector cannot have more than {} elements", + MAX_SIMD_LANES, + ) + .emit(); + return; + } + } + match e.kind() { ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ } _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ } diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index 33b1c0bb2c9..1a11aad1441 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -1460,28 +1460,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ), ); err.span_label(field.ident.span, "field does not exist"); - err.span_label( + err.span_suggestion( ty_span, + &format!( + "`{adt}::{variant}` is a tuple {kind_name}, use the appropriate syntax", + adt = ty, + variant = variant.ident, + ), format!( - "`{adt}::{variant}` is a tuple {kind_name}, \ - use the appropriate syntax: `{adt}::{variant}(/* fields */)`", + "{adt}::{variant}(/* fields */)", adt = ty, variant = variant.ident, - kind_name = kind_name ), + Applicability::HasPlaceholders, ); } _ => { err.span_label(variant.ident.span, format!("`{adt}` defined here", adt = ty)); err.span_label(field.ident.span, "field does not exist"); - err.span_label( + err.span_suggestion( ty_span, - format!( - "`{adt}` is a tuple {kind_name}, \ - use the appropriate syntax: `{adt}(/* fields */)`", + &format!( + "`{adt}` is a tuple {kind_name}, use the appropriate syntax", adt = ty, - kind_name = kind_name + kind_name = kind_name, ), + format!("{adt}(/* fields */)", adt = ty), + Applicability::HasPlaceholders, ); } }, diff --git a/compiler/rustc_typeck/src/check/mod.rs b/compiler/rustc_typeck/src/check/mod.rs index dc3e3b4e738..229127e95d9 100644 --- a/compiler/rustc_typeck/src/check/mod.rs +++ b/compiler/rustc_typeck/src/check/mod.rs @@ -838,7 +838,7 @@ fn missing_items_err( // Obtain the level of indentation ending in `sugg_sp`. let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0); // Make the whitespace that will make the suggestion have the right indentation. - let padding: String = (0..indentation).map(|_| " ").collect(); + let padding: String = std::iter::repeat(" ").take(indentation).collect(); for trait_item in missing_items { let snippet = suggestion_signature(&trait_item, tcx); diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs index 5554a448b5c..c26388a1db1 100644 --- a/library/alloc/src/collections/btree/map.rs +++ b/library/alloc/src/collections/btree/map.rs @@ -11,7 +11,6 @@ use core::ptr; use super::borrow::DormantMutRef; use super::node::{self, marker, ForceResult::*, Handle, NodeRef, Root}; use super::search::SearchResult::*; -use super::unwrap_unchecked; mod entry; pub use entry::{Entry, OccupiedEntry, VacantEntry}; @@ -460,7 +459,7 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for RangeMut<'_, K, V> { } } -impl<K: Ord, V> BTreeMap<K, V> { +impl<K, V> BTreeMap<K, V> { /// Makes a new, empty `BTreeMap`. /// /// Does not allocate anything on its own. @@ -479,7 +478,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] - pub const fn new() -> BTreeMap<K, V> { + pub const fn new() -> BTreeMap<K, V> + where + K: Ord, + { BTreeMap { root: None, length: 0 } } @@ -499,7 +501,7 @@ impl<K: Ord, V> BTreeMap<K, V> { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn clear(&mut self) { - *self = BTreeMap::new(); + *self = BTreeMap { root: None, length: 0 }; } /// Returns a reference to the value corresponding to the key. @@ -522,7 +524,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[stable(feature = "rust1", since = "1.0.0")] pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where - K: Borrow<Q>, + K: Borrow<Q> + Ord, Q: Ord, { let root_node = self.root.as_ref()?.reborrow(); @@ -550,7 +552,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[stable(feature = "map_get_key_value", since = "1.40.0")] pub fn get_key_value<Q: ?Sized>(&self, k: &Q) -> Option<(&K, &V)> where - K: Borrow<Q>, + K: Borrow<Q> + Ord, Q: Ord, { let root_node = self.root.as_ref()?.reborrow(); @@ -578,7 +580,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(map.first_key_value(), Some((&1, &"b"))); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn first_key_value(&self) -> Option<(&K, &V)> { + pub fn first_key_value(&self) -> Option<(&K, &V)> + where + K: Ord, + { let root_node = self.root.as_ref()?.reborrow(); root_node.first_leaf_edge().right_kv().ok().map(Handle::into_kv) } @@ -604,7 +609,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(*map.get(&2).unwrap(), "b"); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn first_entry(&mut self) -> Option<OccupiedEntry<'_, K, V>> { + pub fn first_entry(&mut self) -> Option<OccupiedEntry<'_, K, V>> + where + K: Ord, + { let (map, dormant_map) = DormantMutRef::new(self); let root_node = map.root.as_mut()?.borrow_mut(); let kv = root_node.first_leaf_edge().right_kv().ok()?; @@ -631,7 +639,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert!(map.is_empty()); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn pop_first(&mut self) -> Option<(K, V)> { + pub fn pop_first(&mut self) -> Option<(K, V)> + where + K: Ord, + { self.first_entry().map(|entry| entry.remove_entry()) } @@ -652,7 +663,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(map.last_key_value(), Some((&2, &"a"))); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn last_key_value(&self) -> Option<(&K, &V)> { + pub fn last_key_value(&self) -> Option<(&K, &V)> + where + K: Ord, + { let root_node = self.root.as_ref()?.reborrow(); root_node.last_leaf_edge().left_kv().ok().map(Handle::into_kv) } @@ -678,7 +692,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(*map.get(&2).unwrap(), "last"); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn last_entry(&mut self) -> Option<OccupiedEntry<'_, K, V>> { + pub fn last_entry(&mut self) -> Option<OccupiedEntry<'_, K, V>> + where + K: Ord, + { let (map, dormant_map) = DormantMutRef::new(self); let root_node = map.root.as_mut()?.borrow_mut(); let kv = root_node.last_leaf_edge().left_kv().ok()?; @@ -705,7 +722,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert!(map.is_empty()); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn pop_last(&mut self) -> Option<(K, V)> { + pub fn pop_last(&mut self) -> Option<(K, V)> + where + K: Ord, + { self.last_entry().map(|entry| entry.remove_entry()) } @@ -729,7 +749,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[stable(feature = "rust1", since = "1.0.0")] pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where - K: Borrow<Q>, + K: Borrow<Q> + Ord, Q: Ord, { self.get(key).is_some() @@ -758,7 +778,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where - K: Borrow<Q>, + K: Borrow<Q> + Ord, Q: Ord, { let root_node = self.root.as_mut()?.borrow_mut(); @@ -795,7 +815,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(map[&37], "c"); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, key: K, value: V) -> Option<V> { + pub fn insert(&mut self, key: K, value: V) -> Option<V> + where + K: Ord, + { match self.entry(key) { Occupied(mut entry) => Some(entry.insert(value)), Vacant(entry) => { @@ -827,7 +850,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[stable(feature = "rust1", since = "1.0.0")] pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where - K: Borrow<Q>, + K: Borrow<Q> + Ord, Q: Ord, { self.remove_entry(key).map(|(_, v)| v) @@ -854,7 +877,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[stable(feature = "btreemap_remove_entry", since = "1.45.0")] pub fn remove_entry<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)> where - K: Borrow<Q>, + K: Borrow<Q> + Ord, Q: Ord, { let (map, dormant_map) = DormantMutRef::new(self); @@ -886,6 +909,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[unstable(feature = "btree_retain", issue = "79025")] pub fn retain<F>(&mut self, mut f: F) where + K: Ord, F: FnMut(&K, &mut V) -> bool, { self.drain_filter(|k, v| !f(k, v)); @@ -920,7 +944,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(a[&5], "f"); /// ``` #[stable(feature = "btree_append", since = "1.11.0")] - pub fn append(&mut self, other: &mut Self) { + pub fn append(&mut self, other: &mut Self) + where + K: Ord, + { // Do we have to append anything at all? if other.is_empty() { return; @@ -971,7 +998,7 @@ impl<K: Ord, V> BTreeMap<K, V> { pub fn range<T: ?Sized, R>(&self, range: R) -> Range<'_, K, V> where T: Ord, - K: Borrow<T>, + K: Borrow<T> + Ord, R: RangeBounds<T>, { if let Some(root) = &self.root { @@ -1017,7 +1044,7 @@ impl<K: Ord, V> BTreeMap<K, V> { pub fn range_mut<T: ?Sized, R>(&mut self, range: R) -> RangeMut<'_, K, V> where T: Ord, - K: Borrow<T>, + K: Borrow<T> + Ord, R: RangeBounds<T>, { if let Some(root) = &mut self.root { @@ -1048,7 +1075,10 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(count["a"], 3); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn entry(&mut self, key: K) -> Entry<'_, K, V> { + pub fn entry(&mut self, key: K) -> Entry<'_, K, V> + where + K: Ord, + { // FIXME(@porglezomp) Avoid allocating if we don't insert let (map, dormant_map) = DormantMutRef::new(self); let root_node = Self::ensure_is_owned(&mut map.root).borrow_mut(); @@ -1092,7 +1122,7 @@ impl<K: Ord, V> BTreeMap<K, V> { #[stable(feature = "btree_split_off", since = "1.11.0")] pub fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self where - K: Borrow<Q>, + K: Borrow<Q> + Ord, { if self.is_empty() { return Self::new(); @@ -1117,21 +1147,23 @@ impl<K: Ord, V> BTreeMap<K, V> { right } - /// Creates an iterator which uses a closure to determine if an element should be removed. - /// - /// If the closure returns true, the element is removed from the map and yielded. - /// If the closure returns false, or panics, the element remains in the map and will not be - /// yielded. + /// Creates an iterator that visits all elements (key-value pairs) in + /// ascending key order and uses a closure to determine if an element should + /// be removed. If the closure returns `true`, the element is removed from + /// the map and yielded. If the closure returns `false`, or panics, the + /// element remains in the map and will not be yielded. /// - /// Note that `drain_filter` lets you mutate every value in the filter closure, regardless of - /// whether you choose to keep or remove it. + /// The iterator also lets you mutate the value of each element in the + /// closure, regardless of whether you choose to keep or remove it. /// - /// If the iterator is only partially consumed or not consumed at all, each of the remaining - /// elements will still be subjected to the closure and removed and dropped if it returns true. + /// If the iterator is only partially consumed or not consumed at all, each + /// of the remaining elements is still subjected to the closure, which may + /// change its value and, by returning `true`, have the element removed and + /// dropped. /// - /// It is unspecified how many more elements will be subjected to the closure - /// if a panic occurs in the closure, or a panic occurs while dropping an element, - /// or if the `DrainFilter` value is leaked. + /// It is unspecified how many more elements will be subjected to the + /// closure if a panic occurs in the closure, or a panic occurs while + /// dropping an element, or if the `DrainFilter` value is leaked. /// /// # Examples /// @@ -1150,12 +1182,16 @@ impl<K: Ord, V> BTreeMap<K, V> { #[unstable(feature = "btree_drain_filter", issue = "70530")] pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, K, V, F> where + K: Ord, F: FnMut(&K, &mut V) -> bool, { DrainFilter { pred, inner: self.drain_filter_inner() } } - pub(super) fn drain_filter_inner(&mut self) -> DrainFilterInner<'_, K, V> { + pub(super) fn drain_filter_inner(&mut self) -> DrainFilterInner<'_, K, V> + where + K: Ord, + { if let Some(root) = self.root.as_mut() { let (root, dormant_root) = DormantMutRef::new(root); let front = root.borrow_mut().first_leaf_edge(); @@ -1387,7 +1423,7 @@ impl<K, V> Drop for IntoIter<K, V> { unsafe { let mut node = - unwrap_unchecked(ptr::read(&self.0.front)).into_node().forget_type(); + ptr::read(&self.0.front).unwrap_unchecked().into_node().forget_type(); while let Some(parent) = node.deallocate_and_ascend() { node = parent.into_node().forget_type(); } @@ -1712,7 +1748,7 @@ impl<'a, K, V> Range<'a, K, V> { } unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) { - unsafe { unwrap_unchecked(self.front.as_mut()).next_unchecked() } + unsafe { self.front.as_mut().unwrap_unchecked().next_unchecked() } } } @@ -1801,7 +1837,7 @@ impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V> { impl<'a, K, V> Range<'a, K, V> { unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) { - unsafe { unwrap_unchecked(self.back.as_mut()).next_back_unchecked() } + unsafe { self.back.as_mut().unwrap_unchecked().next_back_unchecked() } } } @@ -1847,7 +1883,7 @@ impl<'a, K, V> RangeMut<'a, K, V> { } unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) { - unsafe { unwrap_unchecked(self.front.as_mut()).next_unchecked() } + unsafe { self.front.as_mut().unwrap_unchecked().next_unchecked() } } /// Returns an iterator of references over the remaining items. @@ -1877,7 +1913,7 @@ impl<K, V> FusedIterator for RangeMut<'_, K, V> {} impl<'a, K, V> RangeMut<'a, K, V> { unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) { - unsafe { unwrap_unchecked(self.back.as_mut()).next_back_unchecked() } + unsafe { self.back.as_mut().unwrap_unchecked().next_back_unchecked() } } } @@ -1968,9 +2004,9 @@ impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<K: Ord, Q: ?Sized, V> Index<&Q> for BTreeMap<K, V> +impl<K, Q: ?Sized, V> Index<&Q> for BTreeMap<K, V> where - K: Borrow<Q>, + K: Borrow<Q> + Ord, Q: Ord, { type Output = V; diff --git a/library/alloc/src/collections/btree/map/tests.rs b/library/alloc/src/collections/btree/map/tests.rs index ba5a4442f56..1993c6e047d 100644 --- a/library/alloc/src/collections/btree/map/tests.rs +++ b/library/alloc/src/collections/btree/map/tests.rs @@ -1707,6 +1707,47 @@ fn test_send() { } #[allow(dead_code)] +fn test_ord_absence() { + fn map<K>(mut map: BTreeMap<K, ()>) { + map.is_empty(); + map.len(); + map.clear(); + map.iter(); + map.iter_mut(); + map.keys(); + map.values(); + map.values_mut(); + if true { + map.into_values(); + } else if true { + map.into_iter(); + } else { + map.into_keys(); + } + } + + fn map_debug<K: Debug>(mut map: BTreeMap<K, ()>) { + format!("{:?}", map); + format!("{:?}", map.iter()); + format!("{:?}", map.iter_mut()); + format!("{:?}", map.keys()); + format!("{:?}", map.values()); + format!("{:?}", map.values_mut()); + if true { + format!("{:?}", map.into_iter()); + } else if true { + format!("{:?}", map.into_keys()); + } else { + format!("{:?}", map.into_values()); + } + } + + fn map_clone<K: Clone>(mut map: BTreeMap<K, ()>) { + map.clone_from(&map.clone()); + } +} + +#[allow(dead_code)] fn test_const() { const MAP: &'static BTreeMap<(), ()> = &BTreeMap::new(); const LEN: usize = MAP.len(); @@ -1882,7 +1923,7 @@ fn test_append_drop_leak() { catch_unwind(move || left.append(&mut right)).unwrap_err(); - assert_eq!(DROPS.load(SeqCst), 5); + assert_eq!(DROPS.load(SeqCst), 4); // Rust issue #47949 ate one little piggy } #[test] diff --git a/library/alloc/src/collections/btree/mod.rs b/library/alloc/src/collections/btree/mod.rs index cdb39104047..cf91c17b511 100644 --- a/library/alloc/src/collections/btree/mod.rs +++ b/library/alloc/src/collections/btree/mod.rs @@ -19,22 +19,6 @@ trait Recover<Q: ?Sized> { fn replace(&mut self, key: Self::Key) -> Option<Self::Key>; } -/// Same purpose as `Option::unwrap` but doesn't always guarantee a panic -/// if the option contains no value. -/// SAFETY: the caller must ensure that the option contains a value. -#[inline(always)] -pub unsafe fn unwrap_unchecked<T>(val: Option<T>) -> T { - val.unwrap_or_else(|| { - if cfg!(debug_assertions) { - panic!("'unchecked' unwrap on None in BTreeMap"); - } else { - unsafe { - core::intrinsics::unreachable(); - } - } - }) -} - #[cfg(test)] /// XorShiftRng struct DeterministicRng { diff --git a/library/alloc/src/collections/btree/navigate.rs b/library/alloc/src/collections/btree/navigate.rs index 2773b427fb1..1ef2a572ddd 100644 --- a/library/alloc/src/collections/btree/navigate.rs +++ b/library/alloc/src/collections/btree/navigate.rs @@ -6,7 +6,6 @@ use core::ptr; use super::node::{marker, ForceResult::*, Handle, NodeRef}; use super::search::SearchResult; -use super::unwrap_unchecked; /// Finds the leaf edges delimiting a specified range in or underneath a node. /// @@ -310,7 +309,7 @@ macro_rules! def_next_kv_uncheched_dealloc { Err(last_edge) => { unsafe { let parent_edge = last_edge.into_node().deallocate_and_ascend(); - unwrap_unchecked(parent_edge).forget_node_type() + parent_edge.unwrap_unchecked().forget_node_type() } } } @@ -331,7 +330,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Ed pub unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) { super::mem::replace(self, |leaf_edge| { let kv = leaf_edge.next_kv(); - let kv = unsafe { unwrap_unchecked(kv.ok()) }; + let kv = unsafe { kv.ok().unwrap_unchecked() }; (kv.next_leaf_edge(), kv.into_kv()) }) } @@ -344,7 +343,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Ed pub unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) { super::mem::replace(self, |leaf_edge| { let kv = leaf_edge.next_back_kv(); - let kv = unsafe { unwrap_unchecked(kv.ok()) }; + let kv = unsafe { kv.ok().unwrap_unchecked() }; (kv.next_back_leaf_edge(), kv.into_kv()) }) } @@ -359,7 +358,7 @@ impl<'a, K, V> Handle<NodeRef<marker::ValMut<'a>, K, V, marker::Leaf>, marker::E pub unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) { let kv = super::mem::replace(self, |leaf_edge| { let kv = leaf_edge.next_kv(); - let kv = unsafe { unwrap_unchecked(kv.ok()) }; + let kv = unsafe { kv.ok().unwrap_unchecked() }; (unsafe { ptr::read(&kv) }.next_leaf_edge(), kv) }); // Doing this last is faster, according to benchmarks. @@ -374,7 +373,7 @@ impl<'a, K, V> Handle<NodeRef<marker::ValMut<'a>, K, V, marker::Leaf>, marker::E pub unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) { let kv = super::mem::replace(self, |leaf_edge| { let kv = leaf_edge.next_back_kv(); - let kv = unsafe { unwrap_unchecked(kv.ok()) }; + let kv = unsafe { kv.ok().unwrap_unchecked() }; (unsafe { ptr::read(&kv) }.next_back_leaf_edge(), kv) }); // Doing this last is faster, according to benchmarks. diff --git a/library/alloc/src/collections/btree/remove.rs b/library/alloc/src/collections/btree/remove.rs index ff842197d19..9cd016fa62f 100644 --- a/library/alloc/src/collections/btree/remove.rs +++ b/library/alloc/src/collections/btree/remove.rs @@ -1,6 +1,5 @@ use super::map::MIN_LEN; use super::node::{marker, ForceResult::*, Handle, LeftOrRight::*, NodeRef}; -use super::unwrap_unchecked; impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, marker::KV> { /// Removes a key-value pair from the tree, and returns that pair, as well as @@ -77,12 +76,12 @@ impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, // the element we were asked to remove. Prefer the left adjacent KV, // for the reasons listed in `choose_parent_kv`. let left_leaf_kv = self.left_edge().descend().last_leaf_edge().left_kv(); - let left_leaf_kv = unsafe { unwrap_unchecked(left_leaf_kv.ok()) }; + let left_leaf_kv = unsafe { left_leaf_kv.ok().unwrap_unchecked() }; let (left_kv, left_hole) = left_leaf_kv.remove_leaf_kv(handle_emptied_internal_root); // The internal node may have been stolen from or merged. Go back right // to find where the original KV ended up. - let mut internal = unsafe { unwrap_unchecked(left_hole.next_kv().ok()) }; + let mut internal = unsafe { left_hole.next_kv().ok().unwrap_unchecked() }; let old_kv = internal.replace_kv(left_kv.0, left_kv.1); let pos = internal.next_leaf_edge(); (old_kv, pos) diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs index d39eb1fd4f9..c619b5bf8ed 100644 --- a/library/alloc/src/collections/btree/set.rs +++ b/library/alloc/src/collections/btree/set.rs @@ -222,7 +222,7 @@ impl<T: fmt::Debug> fmt::Debug for Union<'_, T> { // and it's a power of two to make that division cheap. const ITER_PERFORMANCE_TIPPING_SIZE_DIFF: usize = 16; -impl<T: Ord> BTreeSet<T> { +impl<T> BTreeSet<T> { /// Makes a new, empty `BTreeSet`. /// /// Does not allocate anything on its own. @@ -237,7 +237,10 @@ impl<T: Ord> BTreeSet<T> { /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] - pub const fn new() -> BTreeSet<T> { + pub const fn new() -> BTreeSet<T> + where + T: Ord, + { BTreeSet { map: BTreeMap::new() } } @@ -267,7 +270,7 @@ impl<T: Ord> BTreeSet<T> { pub fn range<K: ?Sized, R>(&self, range: R) -> Range<'_, T> where K: Ord, - T: Borrow<K>, + T: Borrow<K> + Ord, R: RangeBounds<K>, { Range { iter: self.map.range(range) } @@ -294,7 +297,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(diff, [1]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> { + pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> + where + T: Ord, + { let (self_min, self_max) = if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { (self_min, self_max) @@ -352,10 +358,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(sym_diff, [1, 3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn symmetric_difference<'a>( - &'a self, - other: &'a BTreeSet<T>, - ) -> SymmetricDifference<'a, T> { + pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>) -> SymmetricDifference<'a, T> + where + T: Ord, + { SymmetricDifference(MergeIterInner::new(self.iter(), other.iter())) } @@ -380,7 +386,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(intersection, [2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T> { + pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T> + where + T: Ord, + { let (self_min, self_max) = if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { (self_min, self_max) @@ -428,7 +437,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(union, [1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> { + pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> + where + T: Ord, + { Union(MergeIterInner::new(self.iter(), other.iter())) } @@ -467,7 +479,7 @@ impl<T: Ord> BTreeSet<T> { #[stable(feature = "rust1", since = "1.0.0")] pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool where - T: Borrow<Q>, + T: Borrow<Q> + Ord, Q: Ord, { self.map.contains_key(value) @@ -491,7 +503,7 @@ impl<T: Ord> BTreeSet<T> { #[stable(feature = "set_recovery", since = "1.9.0")] pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T> where - T: Borrow<Q>, + T: Borrow<Q> + Ord, Q: Ord, { Recover::get(&self.map, value) @@ -515,7 +527,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(a.is_disjoint(&b), false); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_disjoint(&self, other: &BTreeSet<T>) -> bool { + pub fn is_disjoint(&self, other: &BTreeSet<T>) -> bool + where + T: Ord, + { self.intersection(other).next().is_none() } @@ -537,7 +552,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(set.is_subset(&sup), false); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_subset(&self, other: &BTreeSet<T>) -> bool { + pub fn is_subset(&self, other: &BTreeSet<T>) -> bool + where + T: Ord, + { // Same result as self.difference(other).next().is_none() // but the code below is faster (hugely in some cases). if self.len() > other.len() { @@ -613,7 +631,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(set.is_superset(&sub), true); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_superset(&self, other: &BTreeSet<T>) -> bool { + pub fn is_superset(&self, other: &BTreeSet<T>) -> bool + where + T: Ord, + { other.is_subset(self) } @@ -636,7 +657,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(map.first(), Some(&1)); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn first(&self) -> Option<&T> { + pub fn first(&self) -> Option<&T> + where + T: Ord, + { self.map.first_key_value().map(|(k, _)| k) } @@ -652,14 +676,17 @@ impl<T: Ord> BTreeSet<T> { /// use std::collections::BTreeSet; /// /// let mut map = BTreeSet::new(); - /// assert_eq!(map.first(), None); + /// assert_eq!(map.last(), None); /// map.insert(1); /// assert_eq!(map.last(), Some(&1)); /// map.insert(2); /// assert_eq!(map.last(), Some(&2)); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn last(&self) -> Option<&T> { + pub fn last(&self) -> Option<&T> + where + T: Ord, + { self.map.last_key_value().map(|(k, _)| k) } @@ -681,7 +708,10 @@ impl<T: Ord> BTreeSet<T> { /// assert!(set.is_empty()); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn pop_first(&mut self) -> Option<T> { + pub fn pop_first(&mut self) -> Option<T> + where + T: Ord, + { self.map.pop_first().map(|kv| kv.0) } @@ -703,7 +733,10 @@ impl<T: Ord> BTreeSet<T> { /// assert!(set.is_empty()); /// ``` #[unstable(feature = "map_first_last", issue = "62924")] - pub fn pop_last(&mut self) -> Option<T> { + pub fn pop_last(&mut self) -> Option<T> + where + T: Ord, + { self.map.pop_last().map(|kv| kv.0) } @@ -728,7 +761,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(set.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, value: T) -> bool { + pub fn insert(&mut self, value: T) -> bool + where + T: Ord, + { self.map.insert(value, ()).is_none() } @@ -748,7 +784,10 @@ impl<T: Ord> BTreeSet<T> { /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 10); /// ``` #[stable(feature = "set_recovery", since = "1.9.0")] - pub fn replace(&mut self, value: T) -> Option<T> { + pub fn replace(&mut self, value: T) -> Option<T> + where + T: Ord, + { Recover::replace(&mut self.map, value) } @@ -774,7 +813,7 @@ impl<T: Ord> BTreeSet<T> { #[stable(feature = "rust1", since = "1.0.0")] pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where - T: Borrow<Q>, + T: Borrow<Q> + Ord, Q: Ord, { self.map.remove(value).is_some() @@ -798,7 +837,7 @@ impl<T: Ord> BTreeSet<T> { #[stable(feature = "set_recovery", since = "1.9.0")] pub fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T> where - T: Borrow<Q>, + T: Borrow<Q> + Ord, Q: Ord, { Recover::take(&mut self.map, value) @@ -823,6 +862,7 @@ impl<T: Ord> BTreeSet<T> { #[unstable(feature = "btree_retain", issue = "79025")] pub fn retain<F>(&mut self, mut f: F) where + T: Ord, F: FnMut(&T) -> bool, { self.drain_filter(|v| !f(v)); @@ -857,7 +897,10 @@ impl<T: Ord> BTreeSet<T> { /// assert!(a.contains(&5)); /// ``` #[stable(feature = "btree_append", since = "1.11.0")] - pub fn append(&mut self, other: &mut Self) { + pub fn append(&mut self, other: &mut Self) + where + T: Ord, + { self.map.append(&mut other.map); } @@ -893,7 +936,7 @@ impl<T: Ord> BTreeSet<T> { #[stable(feature = "btree_split_off", since = "1.11.0")] pub fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self where - T: Borrow<Q>, + T: Borrow<Q> + Ord, { BTreeSet { map: self.map.split_off(key) } } @@ -928,13 +971,12 @@ impl<T: Ord> BTreeSet<T> { #[unstable(feature = "btree_drain_filter", issue = "70530")] pub fn drain_filter<'a, F>(&'a mut self, pred: F) -> DrainFilter<'a, T, F> where + T: Ord, F: 'a + FnMut(&T) -> bool, { DrainFilter { pred, inner: self.map.drain_filter_inner() } } -} -impl<T> BTreeSet<T> { /// Gets an iterator that visits the values in the `BTreeSet` in ascending order. /// /// # Examples diff --git a/library/alloc/src/collections/btree/set/tests.rs b/library/alloc/src/collections/btree/set/tests.rs index fd19c0078a7..3762af7236a 100644 --- a/library/alloc/src/collections/btree/set/tests.rs +++ b/library/alloc/src/collections/btree/set/tests.rs @@ -639,6 +639,27 @@ fn test_send() { } } +#[allow(dead_code)] +fn test_ord_absence() { + fn set<K>(mut set: BTreeSet<K>) { + set.is_empty(); + set.len(); + set.clear(); + set.iter(); + set.into_iter(); + } + + fn set_debug<K: Debug>(set: BTreeSet<K>) { + format!("{:?}", set); + format!("{:?}", set.iter()); + format!("{:?}", set.into_iter()); + } + + fn set_clone<K: Clone>(mut set: BTreeSet<K>) { + set.clone_from(&set.clone()); + } +} + #[test] fn test_append() { let mut a = BTreeSet::new(); diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index a49979fb7aa..99c42a4ba44 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -111,6 +111,7 @@ #![feature(nll)] #![feature(nonnull_slice_from_raw_parts)] #![feature(auto_traits)] +#![feature(option_result_unwrap_unchecked)] #![feature(or_patterns)] #![feature(pattern)] #![feature(ptr_internals)] diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs index c572c66ce32..9dc3f05dae5 100644 --- a/library/core/src/alloc/layout.rs +++ b/library/core/src/alloc/layout.rs @@ -400,7 +400,7 @@ impl Layout { #[stable(feature = "alloc_layout", since = "1.28.0")] #[rustc_deprecated( - since = "1.51.0", + since = "1.52.0", reason = "Name does not follow std convention, use LayoutError", suggestion = "LayoutError" )] @@ -409,7 +409,7 @@ pub type LayoutErr = LayoutError; /// The parameters given to `Layout::from_size_align` /// or some other `Layout` constructor /// do not satisfy its documented constraints. -#[stable(feature = "alloc_layout_error", since = "1.49.0")] +#[stable(feature = "alloc_layout_error", since = "1.50.0")] #[derive(Clone, PartialEq, Eq, Debug)] pub struct LayoutError { private: (), diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 045eb58d013..06a761531b6 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -11,14 +11,14 @@ pub use self::global::GlobalAlloc; pub use self::layout::Layout; #[stable(feature = "alloc_layout", since = "1.28.0")] #[rustc_deprecated( - since = "1.51.0", + since = "1.52.0", reason = "Name does not follow std convention, use LayoutError", suggestion = "LayoutError" )] #[allow(deprecated, deprecated_in_future)] pub use self::layout::LayoutErr; -#[stable(feature = "alloc_layout_error", since = "1.49.0")] +#[stable(feature = "alloc_layout_error", since = "1.50.0")] pub use self::layout::LayoutError; use crate::fmt; @@ -342,7 +342,10 @@ pub unsafe trait Allocator { /// /// The returned adaptor also implements `Allocator` and will simply borrow this. #[inline(always)] - fn by_ref(&self) -> &Self { + fn by_ref(&self) -> &Self + where + Self: Sized, + { self } } diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs index 7c1a9b82f99..080a0a21188 100644 --- a/library/core/src/intrinsics.rs +++ b/library/core/src/intrinsics.rs @@ -1586,7 +1586,7 @@ extern "rust-intrinsic" { /// Safe wrappers for this intrinsic are available on the integer /// primitives via the `checked_div` method. For example, /// [`u32::checked_div`] - #[rustc_const_unstable(feature = "const_int_unchecked_arith", issue = "none")] + #[rustc_const_stable(feature = "const_int_unchecked_arith", since = "1.51.0")] pub fn unchecked_div<T: Copy>(x: T, y: T) -> T; /// Returns the remainder of an unchecked division, resulting in /// undefined behavior when `y == 0` or `x == T::MIN && y == -1` @@ -1594,7 +1594,7 @@ extern "rust-intrinsic" { /// Safe wrappers for this intrinsic are available on the integer /// primitives via the `checked_rem` method. For example, /// [`u32::checked_rem`] - #[rustc_const_unstable(feature = "const_int_unchecked_arith", issue = "none")] + #[rustc_const_stable(feature = "const_int_unchecked_arith", since = "1.51.0")] pub fn unchecked_rem<T: Copy>(x: T, y: T) -> T; /// Performs an unchecked left shift, resulting in undefined behavior when diff --git a/library/core/src/iter/adapters/peekable.rs b/library/core/src/iter/adapters/peekable.rs index 2f8b9653c59..43301444e3e 100644 --- a/library/core/src/iter/adapters/peekable.rs +++ b/library/core/src/iter/adapters/peekable.rs @@ -265,7 +265,6 @@ impl<I: Iterator> Peekable<I> { /// # Examples /// Consume a number if it's equal to 0. /// ``` - /// #![feature(peekable_next_if)] /// let mut iter = (0..5).peekable(); /// // The first item of the iterator is 0; consume it. /// assert_eq!(iter.next_if(|&x| x == 0), Some(0)); @@ -277,14 +276,13 @@ impl<I: Iterator> Peekable<I> { /// /// Consume any number less than 10. /// ``` - /// #![feature(peekable_next_if)] /// let mut iter = (1..20).peekable(); /// // Consume all numbers less than 10 /// while iter.next_if(|&x| x < 10).is_some() {} /// // The next value returned will be 10 /// assert_eq!(iter.next(), Some(10)); /// ``` - #[unstable(feature = "peekable_next_if", issue = "72480")] + #[stable(feature = "peekable_next_if", since = "1.51.0")] pub fn next_if(&mut self, func: impl FnOnce(&I::Item) -> bool) -> Option<I::Item> { match self.next() { Some(matched) if func(&matched) => Some(matched), @@ -302,7 +300,6 @@ impl<I: Iterator> Peekable<I> { /// # Example /// Consume a number if it's equal to 0. /// ``` - /// #![feature(peekable_next_if)] /// let mut iter = (0..5).peekable(); /// // The first item of the iterator is 0; consume it. /// assert_eq!(iter.next_if_eq(&0), Some(0)); @@ -311,7 +308,7 @@ impl<I: Iterator> Peekable<I> { /// // `next_if_eq` saves the value of the next item if it was not equal to `expected`. /// assert_eq!(iter.next(), Some(1)); /// ``` - #[unstable(feature = "peekable_next_if", issue = "72480")] + #[stable(feature = "peekable_next_if", since = "1.51.0")] pub fn next_if_eq<T>(&mut self, expected: &T) -> Option<I::Item> where T: ?Sized, diff --git a/library/core/src/iter/traits/exact_size.rs b/library/core/src/iter/traits/exact_size.rs index 996d62e2b4a..167db3359f2 100644 --- a/library/core/src/iter/traits/exact_size.rs +++ b/library/core/src/iter/traits/exact_size.rs @@ -13,6 +13,12 @@ /// implement it. However, you may be able to provide a more performant /// implementation than the default, so overriding it in this case makes sense. /// +/// Note that this trait is a safe trait and as such does *not* and *cannot* +/// guarantee that the returned length is correct. This means that `unsafe` +/// code **must not** rely on the correctness of [`Iterator::size_hint`]. The +/// unstable and unsafe [`TrustedLen`](super::marker::TrustedLen) trait gives +/// this additional guarantee. +/// /// [`len`]: ExactSizeIterator::len /// /// # Examples diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index a69b840e4bf..fd4a76c1eb5 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -73,11 +73,8 @@ #![feature(const_discriminant)] #![feature(const_cell_into_inner)] #![feature(const_intrinsic_copy)] -#![feature(const_checked_int_methods)] -#![feature(const_euclidean_int_methods)] #![feature(const_float_classify)] #![feature(const_float_bits_conv)] -#![feature(const_overflowing_int_methods)] #![feature(const_int_unchecked_arith)] #![feature(const_mut_refs)] #![feature(const_cttz)] diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs index 6a7e4b2ba25..7aaf5a5fd46 100644 --- a/library/core/src/macros/mod.rs +++ b/library/core/src/macros/mod.rs @@ -1324,6 +1324,14 @@ pub(crate) mod builtin { (false) => {{ /* compiler built-in */ }}; } + /// Attribute macro used to apply derive macros. + #[cfg(not(bootstrap))] + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_builtin_macro] + pub macro derive($item:item) { + /* compiler built-in */ + } + /// Attribute macro applied to a function to turn it into a unit test. #[stable(feature = "rust1", since = "1.0.0")] #[allow_internal_unstable(test, rustc_attrs)] diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs index 05bcd90d3ca..3760f5c4794 100644 --- a/library/core/src/mem/maybe_uninit.rs +++ b/library/core/src/mem/maybe_uninit.rs @@ -172,11 +172,42 @@ use crate::ptr; /// /// ## Initializing a struct field-by-field /// -/// There is currently no supported way to create a raw pointer or reference -/// to a field of a struct inside `MaybeUninit<Struct>`. That means it is not possible -/// to create a struct by calling `MaybeUninit::uninit::<Struct>()` and then writing -/// to its fields. +/// You can use `MaybeUninit<T>`, and the [`std::ptr::addr_of_mut`] macro, to initialize structs field by field: /// +/// ```rust +/// use std::mem::MaybeUninit; +/// use std::ptr::addr_of_mut; +/// +/// #[derive(Debug, PartialEq)] +/// pub struct Foo { +/// name: String, +/// list: Vec<u8>, +/// } +/// +/// let foo = { +/// let mut uninit: MaybeUninit<Foo> = MaybeUninit::uninit(); +/// let ptr = uninit.as_mut_ptr(); +/// +/// // Initializing the `name` field +/// unsafe { addr_of_mut!((*ptr).name).write("Bob".to_string()); } +/// +/// // Initializing the `list` field +/// // If there is a panic here, then the `String` in the `name` field leaks. +/// unsafe { addr_of_mut!((*ptr).list).write(vec![0, 1, 2]); } +/// +/// // All the fields are initialized, so we call `assume_init` to get an initialized Foo. +/// unsafe { uninit.assume_init() } +/// }; +/// +/// assert_eq!( +/// foo, +/// Foo { +/// name: "Bob".to_string(), +/// list: vec![0, 1, 2] +/// } +/// ); +/// ``` +/// [`std::ptr::addr_of_mut`]: crate::ptr::addr_of_mut /// [ub]: ../../reference/behavior-considered-undefined.html /// /// # Layout diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs index 8fdd7c9e5d7..1a60c3c7b7e 100644 --- a/library/core/src/num/int_macros.rs +++ b/library/core/src/num/int_macros.rs @@ -513,7 +513,7 @@ macro_rules! int_impl { #[doc = concat!("assert_eq!((1", stringify!($SelfT), ").checked_div(0), None);")] /// ``` #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -539,7 +539,7 @@ macro_rules! int_impl { #[doc = concat!("assert_eq!((1", stringify!($SelfT), ").checked_div_euclid(0), None);")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -565,7 +565,7 @@ macro_rules! int_impl { #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_rem(-1), None);")] /// ``` #[stable(feature = "wrapping", since = "1.7.0")] - #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -591,7 +591,7 @@ macro_rules! int_impl { #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_rem_euclid(-1), None);")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -949,7 +949,7 @@ macro_rules! int_impl { /// assert_eq!((-128i8).wrapping_div(-1), -128); /// ``` #[stable(feature = "num_wrapping", since = "1.2.0")] - #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_wrapping_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -977,7 +977,7 @@ macro_rules! int_impl { /// assert_eq!((-128i8).wrapping_div_euclid(-1), -128); /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1005,7 +1005,7 @@ macro_rules! int_impl { /// assert_eq!((-128i8).wrapping_rem(-1), 0); /// ``` #[stable(feature = "num_wrapping", since = "1.2.0")] - #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_wrapping_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1032,7 +1032,7 @@ macro_rules! int_impl { /// assert_eq!((-128i8).wrapping_rem_euclid(-1), 0); /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1299,7 +1299,7 @@ macro_rules! int_impl { /// ``` #[inline] #[stable(feature = "wrapping", since = "1.7.0")] - #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_overflowing_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) { @@ -1329,7 +1329,7 @@ macro_rules! int_impl { /// ``` #[inline] #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] pub const fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool) { @@ -1360,7 +1360,7 @@ macro_rules! int_impl { /// ``` #[inline] #[stable(feature = "wrapping", since = "1.7.0")] - #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_overflowing_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) { @@ -1390,7 +1390,7 @@ macro_rules! int_impl { #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.overflowing_rem_euclid(-1), (0, true));")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1615,7 +1615,7 @@ macro_rules! int_impl { /// assert_eq!((-a).div_euclid(-b), 2); // -7 >= -4 * 2 /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1653,7 +1653,7 @@ macro_rules! int_impl { /// assert_eq!((-a).rem_euclid(-b), 1); /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs index 9fccf3f72ce..ff5f432acd8 100644 --- a/library/core/src/num/uint_macros.rs +++ b/library/core/src/num/uint_macros.rs @@ -522,7 +522,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_div(0), None);")] /// ``` #[stable(feature = "rust1", since = "1.0.0")] - #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -548,7 +548,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_div_euclid(0), None);")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -573,7 +573,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem(0), None);")] /// ``` #[stable(feature = "wrapping", since = "1.7.0")] - #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -599,7 +599,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(0), None);")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -876,7 +876,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_div(10), 10);")] /// ``` #[stable(feature = "num_wrapping", since = "1.2.0")] - #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_wrapping_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -901,7 +901,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_div_euclid(10), 10);")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -924,7 +924,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_rem(10), 0);")] /// ``` #[stable(feature = "num_wrapping", since = "1.2.0")] - #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_wrapping_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -950,7 +950,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_rem_euclid(10), 0);")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1185,7 +1185,7 @@ macro_rules! uint_impl { /// ``` #[inline] #[stable(feature = "wrapping", since = "1.7.0")] - #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_overflowing_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) { @@ -1215,7 +1215,7 @@ macro_rules! uint_impl { /// ``` #[inline] #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] pub const fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool) { @@ -1242,7 +1242,7 @@ macro_rules! uint_impl { /// ``` #[inline] #[stable(feature = "wrapping", since = "1.7.0")] - #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_overflowing_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) { @@ -1272,7 +1272,7 @@ macro_rules! uint_impl { /// ``` #[inline] #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) { @@ -1456,7 +1456,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(7", stringify!($SelfT), ".div_euclid(4), 1); // or any other integer type")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] @@ -1484,7 +1484,7 @@ macro_rules! uint_impl { #[doc = concat!("assert_eq!(7", stringify!($SelfT), ".rem_euclid(4), 3); // or any other integer type")] /// ``` #[stable(feature = "euclidean_division", since = "1.38.0")] - #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")] + #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.51.0")] #[must_use = "this returns the result of the operation, \ without modifying the original"] #[inline] diff --git a/library/core/src/prelude/v1.rs b/library/core/src/prelude/v1.rs index b4fff3d67b5..a1fbd8dec75 100644 --- a/library/core/src/prelude/v1.rs +++ b/library/core/src/prelude/v1.rs @@ -69,6 +69,11 @@ pub use crate::macros::builtin::{ bench, global_allocator, test, test_case, RustcDecodable, RustcEncodable, }; +#[cfg(not(bootstrap))] +#[stable(feature = "builtin_macro_prelude", since = "1.38.0")] +#[doc(no_inline)] +pub use crate::macros::builtin::derive; + #[unstable( feature = "cfg_accessible", issue = "64797", diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index bc0e3e059c9..4dc86e0f5f4 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -65,7 +65,6 @@ #![feature(unwrap_infallible)] #![feature(option_result_unwrap_unchecked)] #![feature(option_unwrap_none)] -#![feature(peekable_next_if)] #![feature(peekable_peek_mut)] #![feature(partition_point)] #![feature(once_cell)] diff --git a/library/std/src/lazy/tests.rs b/library/std/src/lazy/tests.rs index a170edbd997..83466eb0904 100644 --- a/library/std/src/lazy/tests.rs +++ b/library/std/src/lazy/tests.rs @@ -48,6 +48,7 @@ fn spawn_and_wait<R: Send + 'static>(f: impl FnOnce() -> R + Send + 'static) -> } #[test] +#[cfg_attr(target_os = "emscripten", ignore)] fn sync_once_cell() { static ONCE_CELL: SyncOnceCell<i32> = SyncOnceCell::new(); @@ -81,6 +82,7 @@ fn sync_once_cell_get_unchecked() { } #[test] +#[cfg_attr(target_os = "emscripten", ignore)] fn sync_once_cell_drop() { static DROP_CNT: AtomicUsize = AtomicUsize::new(0); struct Dropper; @@ -158,6 +160,7 @@ fn into_inner() { } #[test] +#[cfg_attr(target_os = "emscripten", ignore)] fn sync_lazy_new() { static CALLED: AtomicUsize = AtomicUsize::new(0); static SYNC_LAZY: SyncLazy<i32> = SyncLazy::new(|| { @@ -204,6 +207,7 @@ fn sync_lazy_default() { } #[test] +#[cfg_attr(target_os = "emscripten", ignore)] fn static_sync_lazy() { static XS: SyncLazy<Vec<i32>> = SyncLazy::new(|| { let mut xs = Vec::new(); @@ -279,6 +283,7 @@ fn eval_once_macro() { } #[test] +#[cfg_attr(target_os = "emscripten", ignore)] fn sync_once_cell_does_not_leak_partially_constructed_boxes() { static ONCE_CELL: SyncOnceCell<String> = SyncOnceCell::new(); diff --git a/library/std/src/prelude/v1.rs b/library/std/src/prelude/v1.rs index 26302d0ecf2..ef9aec54a4c 100644 --- a/library/std/src/prelude/v1.rs +++ b/library/std/src/prelude/v1.rs @@ -54,6 +54,11 @@ pub use core::prelude::v1::{ bench, global_allocator, test, test_case, RustcDecodable, RustcEncodable, }; +#[cfg(not(bootstrap))] +#[stable(feature = "builtin_macro_prelude", since = "1.38.0")] +#[doc(hidden)] +pub use core::prelude::v1::derive; + #[unstable( feature = "cfg_accessible", issue = "64797", diff --git a/library/std/src/sys/wasi/ext/fs.rs b/library/std/src/sys/wasi/ext/fs.rs index 4f7cf6018d9..a8da003d550 100644 --- a/library/std/src/sys/wasi/ext/fs.rs +++ b/library/std/src/sys/wasi/ext/fs.rs @@ -514,3 +514,11 @@ pub fn symlink<P: AsRef<Path>, U: AsRef<Path>>( .fd() .symlink(osstr2str(old_path.as_ref().as_ref())?, osstr2str(new_path.as_ref().as_ref())?) } + +/// Create a symbolic link. +/// +/// This is a convenience API similar to [`std::os::unix::fs::symlink`] and +/// [`std::os::windows::fs::symlink_file`] and [`symlink_dir`](std::os::windows::fs::symlink_dir). +pub fn symlink_path<P: AsRef<Path>, U: AsRef<Path>>(old_path: P, new_path: U) -> io::Result<()> { + crate::sys::fs::symlink(old_path.as_ref(), new_path.as_ref()) +} diff --git a/library/test/src/cli.rs b/library/test/src/cli.rs index 02c529252e0..c0b5197e997 100644 --- a/library/test/src/cli.rs +++ b/library/test/src/cli.rs @@ -10,7 +10,7 @@ use super::time::TestTimeOptions; #[derive(Debug)] pub struct TestOpts { pub list: bool, - pub filter: Option<String>, + pub filters: Vec<String>, pub filter_exact: bool, pub force_run_in_process: bool, pub exclude_should_panic: bool, @@ -148,12 +148,13 @@ fn optgroups() -> getopts::Options { } fn usage(binary: &str, options: &getopts::Options) { - let message = format!("Usage: {} [OPTIONS] [FILTER]", binary); + let message = format!("Usage: {} [OPTIONS] [FILTERS...]", binary); println!( r#"{usage} The FILTER string is tested against the name of all tests, and only those -tests whose names contain the filter are run. +tests whose names contain the filter are run. Multiple filter strings may +be passed, which will run all tests matching any of the filters. By default, all tests are run in parallel. This can be altered with the --test-threads flag or the RUST_TEST_THREADS environment variable when running @@ -243,7 +244,7 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes { let logfile = get_log_file(&matches)?; let run_ignored = get_run_ignored(&matches, include_ignored)?; - let filter = get_filter(&matches)?; + let filters = matches.free.clone(); let nocapture = get_nocapture(&matches)?; let test_threads = get_test_threads(&matches)?; let color = get_color_config(&matches)?; @@ -253,7 +254,7 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes { let test_opts = TestOpts { list, - filter, + filters, filter_exact: exact, force_run_in_process, exclude_should_panic, @@ -397,12 +398,6 @@ fn get_run_ignored(matches: &getopts::Matches, include_ignored: bool) -> OptPart Ok(run_ignored) } -fn get_filter(matches: &getopts::Matches) -> OptPartRes<Option<String>> { - let filter = if !matches.free.is_empty() { Some(matches.free[0].clone()) } else { None }; - - Ok(filter) -} - fn get_allow_unstable(matches: &getopts::Matches) -> OptPartRes<bool> { let mut allow_unstable = false; diff --git a/library/test/src/lib.rs b/library/test/src/lib.rs index 3ff79eaea49..c38a8c965be 100644 --- a/library/test/src/lib.rs +++ b/library/test/src/lib.rs @@ -396,8 +396,8 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescA }; // Remove tests that don't match the test filter - if let Some(ref filter) = opts.filter { - filtered.retain(|test| matches_filter(test, filter)); + if !opts.filters.is_empty() { + filtered.retain(|test| opts.filters.iter().any(|filter| matches_filter(test, filter))); } // Skip tests that match any of the skip filters diff --git a/library/test/src/tests.rs b/library/test/src/tests.rs index f0586d510db..e3c9b386915 100644 --- a/library/test/src/tests.rs +++ b/library/test/src/tests.rs @@ -27,7 +27,6 @@ use crate::{ }, time::{TestTimeOptions, TimeThreshold}, }; -use std::any::TypeId; use std::sync::mpsc::channel; use std::time::Duration; @@ -35,7 +34,7 @@ impl TestOpts { fn new() -> TestOpts { TestOpts { list: false, - filter: None, + filters: vec![], filter_exact: false, force_run_in_process: false, exclude_should_panic: false, @@ -198,6 +197,7 @@ fn test_should_panic_bad_message() { #[cfg(not(target_os = "emscripten"))] fn test_should_panic_non_string_message_type() { use crate::tests::TrFailedMsg; + use std::any::TypeId; fn f() { std::panic::panic_any(1i32); } @@ -473,43 +473,60 @@ pub fn exact_filter_match() { } let substr = - filter_tests(&TestOpts { filter: Some("base".into()), ..TestOpts::new() }, tests()); + filter_tests(&TestOpts { filters: vec!["base".into()], ..TestOpts::new() }, tests()); assert_eq!(substr.len(), 4); - let substr = filter_tests(&TestOpts { filter: Some("bas".into()), ..TestOpts::new() }, tests()); + let substr = + filter_tests(&TestOpts { filters: vec!["bas".into()], ..TestOpts::new() }, tests()); assert_eq!(substr.len(), 4); let substr = - filter_tests(&TestOpts { filter: Some("::test".into()), ..TestOpts::new() }, tests()); + filter_tests(&TestOpts { filters: vec!["::test".into()], ..TestOpts::new() }, tests()); assert_eq!(substr.len(), 3); let substr = - filter_tests(&TestOpts { filter: Some("base::test".into()), ..TestOpts::new() }, tests()); + filter_tests(&TestOpts { filters: vec!["base::test".into()], ..TestOpts::new() }, tests()); assert_eq!(substr.len(), 3); + let substr = filter_tests( + &TestOpts { filters: vec!["test1".into(), "test2".into()], ..TestOpts::new() }, + tests(), + ); + assert_eq!(substr.len(), 2); + let exact = filter_tests( - &TestOpts { filter: Some("base".into()), filter_exact: true, ..TestOpts::new() }, + &TestOpts { filters: vec!["base".into()], filter_exact: true, ..TestOpts::new() }, tests(), ); assert_eq!(exact.len(), 1); let exact = filter_tests( - &TestOpts { filter: Some("bas".into()), filter_exact: true, ..TestOpts::new() }, + &TestOpts { filters: vec!["bas".into()], filter_exact: true, ..TestOpts::new() }, tests(), ); assert_eq!(exact.len(), 0); let exact = filter_tests( - &TestOpts { filter: Some("::test".into()), filter_exact: true, ..TestOpts::new() }, + &TestOpts { filters: vec!["::test".into()], filter_exact: true, ..TestOpts::new() }, tests(), ); assert_eq!(exact.len(), 0); let exact = filter_tests( - &TestOpts { filter: Some("base::test".into()), filter_exact: true, ..TestOpts::new() }, + &TestOpts { filters: vec!["base::test".into()], filter_exact: true, ..TestOpts::new() }, tests(), ); assert_eq!(exact.len(), 1); + + let exact = filter_tests( + &TestOpts { + filters: vec!["base".into(), "base::test".into()], + filter_exact: true, + ..TestOpts::new() + }, + tests(), + ); + assert_eq!(exact.len(), 2); } #[test] diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index f0e33be757d..d9132f20d85 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -1880,8 +1880,7 @@ impl Step for RemoteCopyLibs { builder.info(&format!("REMOTE copy libs to emulator ({})", target)); t!(fs::create_dir_all(builder.out.join("tmp"))); - let server = - builder.ensure(tool::RemoteTestServer { compiler: compiler.with_stage(0), target }); + let server = builder.ensure(tool::RemoteTestServer { compiler, target }); // Spawn the emulator and wait for it to come online let tool = builder.tool_exe(Tool::RemoteTestClient); diff --git a/src/ci/docker/host-x86_64/wasm32/Dockerfile b/src/ci/docker/host-x86_64/wasm32/Dockerfile index 096b6645346..878c4e34158 100644 --- a/src/ci/docker/host-x86_64/wasm32/Dockerfile +++ b/src/ci/docker/host-x86_64/wasm32/Dockerfile @@ -1,6 +1,6 @@ -FROM ubuntu:16.04 +FROM ubuntu:20.04 -RUN apt-get update && apt-get install -y --no-install-recommends \ +RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \ g++ \ make \ ninja-build \ @@ -51,12 +51,6 @@ ENV EMCC_CFLAGS=-O1 # Emscripten installation is user-specific ENV NO_CHANGE_USER=1 -# FIXME: Re-enable these tests once https://github.com/rust-lang/cargo/pull/7476 -# is picked up by CI +# Exclude library/alloc due to OOM in benches. ENV SCRIPT python3 ../x.py test --stage 2 --host='' --target $TARGETS \ - --exclude library/core \ - --exclude library/alloc \ - --exclude library/proc_macro \ - --exclude library/std \ - --exclude library/term \ - --exclude library/test + --exclude library/alloc diff --git a/src/ci/scripts/install-awscli.sh b/src/ci/scripts/install-awscli.sh index f9b759fe343..3d8f0de7a39 100755 --- a/src/ci/scripts/install-awscli.sh +++ b/src/ci/scripts/install-awscli.sh @@ -27,7 +27,7 @@ if isLinux; then pip="pip3" pipflags="--user" - sudo apt-get install -y python3-setuptools + sudo apt-get install -y python3-setuptools python3-wheel ciCommandAddPath "${HOME}/.local/bin" fi diff --git a/src/doc/rustc/src/exploit-mitigations.md b/src/doc/rustc/src/exploit-mitigations.md index 44d5d9564f2..70df5170b21 100644 --- a/src/doc/rustc/src/exploit-mitigations.md +++ b/src/doc/rustc/src/exploit-mitigations.md @@ -378,7 +378,7 @@ C library default allocator<sup id="fnref:5" role="doc-noteref"><a href="#fn:5" class="footnote">5</a></sup> since version 1.32.0 (2019-01-17)[39]. -```ignore +```rust,no_run fn main() { let mut x = Box::new([0; 1024]); diff --git a/src/doc/rustc/src/lints/levels.md b/src/doc/rustc/src/lints/levels.md index 64cbbbb0035..3e616f226ed 100644 --- a/src/doc/rustc/src/lints/levels.md +++ b/src/doc/rustc/src/lints/levels.md @@ -62,7 +62,7 @@ warning: unused variable: `x` A 'deny' lint produces an error if you violate it. For example, this code runs into the `exceeding_bitshifts` lint. -```rust,ignore +```rust,no_run fn main() { 100u8 << 10; } @@ -232,7 +232,7 @@ pub fn foo() {} This is the maximum level for all lints. So for example, if we take our code sample from the "deny" lint level above: -```rust,ignore +```rust,no_run fn main() { 100u8 << 10; } diff --git a/src/doc/rustc/src/lints/listing/index.md b/src/doc/rustc/src/lints/listing/index.md index 18cd2fe32a3..97aa2caf915 100644 --- a/src/doc/rustc/src/lints/listing/index.md +++ b/src/doc/rustc/src/lints/listing/index.md @@ -2,4 +2,4 @@ This section lists out all of the lints, grouped by their default lint levels. -You can also see this list by running `rustc -W help`. \ No newline at end of file +You can also see this list by running `rustc -W help`. diff --git a/src/doc/rustc/src/what-is-rustc.md b/src/doc/rustc/src/what-is-rustc.md index 9dcc9f7daa9..39a05cfe205 100644 --- a/src/doc/rustc/src/what-is-rustc.md +++ b/src/doc/rustc/src/what-is-rustc.md @@ -39,7 +39,7 @@ $ .\hello.exe # on Windows Note that we only ever pass `rustc` the *crate root*, not every file we wish to compile. For example, if we had a `main.rs` that looked like this: -```rust,ignore +```rust,ignore (needs-multiple-files) mod foo; fn main() { @@ -49,7 +49,7 @@ fn main() { And a `foo.rs` that had this: -```rust,ignore +```rust,no_run pub fn hello() { println!("Hello, world!"); } diff --git a/src/doc/rustdoc/src/advanced-features.md b/src/doc/rustdoc/src/advanced-features.md index 5128ff13b7a..abdc2e4025d 100644 --- a/src/doc/rustdoc/src/advanced-features.md +++ b/src/doc/rustdoc/src/advanced-features.md @@ -47,8 +47,7 @@ all type errors and name resolution errors with function bodies. Note that this work for anything outside a function body: since Rustdoc documents your types, it has to know what those types are! For example, this code will work regardless of the platform: -<!-- `ignore` because doc-tests are run with `rustc`, not `rustdoc` --> -```ignore +```rust,ignore (platform-specific,rustdoc-specific-behavior) pub fn f() { use std::os::windows::ffi::OsStrExt; } @@ -56,7 +55,7 @@ pub fn f() { but this will not, because the unknown type is part of the function signature: -```ignore +```rust,ignore (platform-specific,rustdoc-specific-behavior) pub fn f() -> std::os::windows::ffi::EncodeWide<'static> { unimplemented!() } diff --git a/src/doc/rustdoc/src/documentation-tests.md b/src/doc/rustdoc/src/documentation-tests.md index 387d86189b0..8e3c6228189 100644 --- a/src/doc/rustdoc/src/documentation-tests.md +++ b/src/doc/rustdoc/src/documentation-tests.md @@ -5,12 +5,13 @@ that examples within your documentation are up to date and working. The basic idea is this: -```ignore +```rust,no_run /// # Examples /// /// ``` /// let x = 5; /// ``` +# fn f() {} ``` The triple backticks start and end code blocks. If this were in a file named `foo.rs`, @@ -78,12 +79,13 @@ Sometimes, you need some setup code, or other things that would distract from your example, but are important to make the tests work. Consider an example block that looks like this: -```ignore +```rust,no_run /// ``` /// /// Some documentation. /// # fn foo() {} // this function will be hidden /// println!("Hello, World!"); /// ``` +# fn f() {} ``` It will render like this: @@ -196,12 +198,13 @@ When writing an example, it is rarely useful to include a complete error handling, as it would add significant amounts of boilerplate code. Instead, you may want the following: -```ignore +```rust,no_run /// ``` /// use std::io; /// let mut input = String::new(); /// io::stdin().read_line(&mut input)?; /// ``` +# fn f() {} ``` The problem is that `?` returns a `Result<T, E>` and test functions don't @@ -210,7 +213,7 @@ return anything, so this will give a mismatched types error. You can get around this limitation by manually adding a `main` that returns `Result<T, E>`, because `Result<T, E>` implements the `Termination` trait: -```ignore +```rust,no_run /// A doc test using ? /// /// ``` @@ -222,12 +225,13 @@ You can get around this limitation by manually adding a `main` that returns /// Ok(()) /// } /// ``` +# fn f() {} ``` Together with the `# ` from the section above, you arrive at a solution that appears to the reader as the initial idea but works with doc tests: -```ignore +```rust,no_run /// ``` /// use std::io; /// # fn main() -> io::Result<()> { @@ -236,18 +240,20 @@ appears to the reader as the initial idea but works with doc tests: /// # Ok(()) /// # } /// ``` +# fn f() {} ``` As of version 1.34.0, one can also omit the `fn main()`, but you will have to disambiguate the error type: -```ignore +```rust,no_run /// ``` /// use std::io; /// let mut input = String::new(); /// io::stdin().read_line(&mut input)?; /// # Ok::<(), io::Error>(()) /// ``` +# fn f() {} ``` This is an unfortunate consequence of the `?` operator adding an implicit @@ -417,7 +423,7 @@ Another possible use of `#[cfg(doctest)]` is to test doctests that are included without including it in your main documentation. For example, you could write this into your `lib.rs` to test your README as part of your doctests: -```rust,ignore +```rust,no_run #![feature(external_doc)] #[doc(include = "../README.md")] diff --git a/src/doc/rustdoc/src/how-to-write-documentation.md b/src/doc/rustdoc/src/how-to-write-documentation.md index 41736e5ee3a..9938cddc941 100644 --- a/src/doc/rustdoc/src/how-to-write-documentation.md +++ b/src/doc/rustdoc/src/how-to-write-documentation.md @@ -7,7 +7,7 @@ implementation detail, or leaves readers with unanswered questions. There are a few tenets to Rust documentation that can help guide anyone through the process of documenting libraries so that everyone has an ample opportunity -to use the code. +to use the code. This chapter covers not only how to write documentation but specifically how to write **good** documentation. It is important to be as clear @@ -19,31 +19,31 @@ then it should be documented. Documenting a crate should begin with front-page documentation. As an example, the [`hashbrown`] crate level documentation summarizes the role of -the crate, provides links to explain technical details, and explains why you -would want to use the crate. +the crate, provides links to explain technical details, and explains why you +would want to use the crate. -After introducing the crate, it is important that the front-page gives +After introducing the crate, it is important that the front-page gives an example of how to use the crate in a real world setting. Stick to the library's role in the example, but do so without shortcuts to benefit users who -may copy and paste the example to get started. +may copy and paste the example to get started. [`futures`] uses inline comments to explain line by line -the complexities of using a [`Future`], because a person's first exposure to +the complexities of using a [`Future`], because a person's first exposure to rust's [`Future`] may be this example. -The [`backtrace`] documentation walks through the whole process, explaining +The [`backtrace`] documentation walks through the whole process, explaining changes made to the `Cargo.toml` file, passing command line arguments to the -compiler, and shows a quick example of backtrace in the wild. +compiler, and shows a quick example of backtrace in the wild. Finally, the front-page can eventually become a comprehensive reference how to use a crate, like [`regex`]. In this front page, all -requirements are outlined, the edge cases shown, and practical examples +requirements are outlined, the edge cases shown, and practical examples provided. The front page goes on to show how to use regular expressions then concludes with crate features. Don't worry about comparing your crate, which is just beginning, to other more developed crates. To get the documentation to something more polished, start -incrementally and put in an introduction, example, and features. Rome was not +incrementally and put in an introduction, example, and features. Rome was not built in a day! The first lines within the `lib.rs` will compose the front-page, and they @@ -51,7 +51,7 @@ use a different convention than the rest of the rustdocs. Lines should start with `//!` which indicate module-level or crate-level documentation. Here's a quick example of the difference: -```rust,ignore +```rust,no_run //! Fast and easy queue abstraction. //! //! Provides an abstraction over a queue. When the abstraction is used @@ -64,13 +64,13 @@ Here's a quick example of the difference: /// This module makes it easy. pub mod easy { - /// Use the abstract function to do this specific thing. - pub fn abstract() {} + /// Use the abstraction function to do this specific thing. + pub fn abstraction() {} } ``` -Ideally, this first line of documentation is a sentence without highly +Ideally, this first line of documentation is a sentence without highly technical details, but with a good description of where this crate fits within the rust ecosystem. Users should know whether this crate meets their use case after reading this line. @@ -95,7 +95,7 @@ It is recommended that each item's documentation follows this basic structure: This basic structure should be straightforward to follow when writing your documentation; while you might think that a code example is trivial, -the examples are really important because they can help users understand +the examples are really important because they can help users understand what an item is, how it is used, and for what purpose it exists. Let's see an example coming from the [standard library] by taking a look at the @@ -133,7 +133,7 @@ for argument in env::args() { [`args_os`]: ./fn.args_os.html `````` -Everything before the first empty line will be reused to describe the component +Everything before the first empty line will be reused to describe the component in searches and module overviews. For example, the function `std::env::args()` above will be shown on the [`std::env`] module documentation. It is good practice to keep the summary to one line: concise writing is a goal of good @@ -221,11 +221,30 @@ This example will render similarly to this: See the specification for the [GitHub Tables extension][tables] for more details on the exact syntax supported. +### Task lists + +Task lists can be used as a checklist of items that have been completed. +Example: + +```md +- [x] Complete task +- [ ] IncComplete task +``` + +This will render as + +<ul> + <li><input type="checkbox"></li> + <li><input type="checkbox" checked></li> +</ul> + +See the specification for the [task list extension] for more details. + [`backtrace`]: https://docs.rs/backtrace/0.3.50/backtrace/ [commonmark markdown specification]: https://commonmark.org/ [commonmark quick reference]: https://commonmark.org/help/ [env::args]: https://doc.rust-lang.org/stable/std/env/fn.args.html -[`Future`]: https://doc.rust-lang.org/std/future/trait.Future.html +[`Future`]: https://doc.rust-lang.org/std/future/trait.Future.html [`futures`]: https://docs.rs/futures/0.3.5/futures/ [`hashbrown`]: https://docs.rs/hashbrown/0.8.2/hashbrown/ [`regex`]: https://docs.rs/regex/1.3.9/regex/ @@ -234,3 +253,4 @@ details on the exact syntax supported. [`std::env`]: https://doc.rust-lang.org/stable/std/env/index.html#functions [strikethrough]: https://github.github.com/gfm/#strikethrough-extension- [tables]: https://github.github.com/gfm/#tables-extension- +[task list extension]: https://github.github.com/gfm/#task-list-items-extension- diff --git a/src/doc/rustdoc/src/lints.md b/src/doc/rustdoc/src/lints.md index 41292b3d838..cce3623dc8f 100644 --- a/src/doc/rustdoc/src/lints.md +++ b/src/doc/rustdoc/src/lints.md @@ -3,10 +3,11 @@ `rustdoc` provides lints to help you writing and testing your documentation. You can use them like any other lints by doing this: -```rust,ignore +```rust #![allow(missing_docs)] // allows the lint, no diagnostics will be reported #![warn(missing_docs)] // warn if there are missing docs #![deny(missing_docs)] // error if there are missing docs +# //! Crate docs. ``` Here is the list of the lints provided by `rustdoc`: diff --git a/src/doc/rustdoc/src/passes.md b/src/doc/rustdoc/src/passes.md index 081e477de80..140b832f19a 100644 --- a/src/doc/rustdoc/src/passes.md +++ b/src/doc/rustdoc/src/passes.md @@ -32,8 +32,9 @@ Without this pass, these items will remain in the output. When you write a doc comment like this: -```rust,ignore +```rust,no_run /// This is a documentation comment. +# fn f() {} ``` There's a space between the `///` and that `T`. That spacing isn't intended @@ -52,9 +53,10 @@ documentation string. For example: -```rust,ignore +```rust,no_run #[doc = "This is the first line."] #[doc = "This is the second line."] +# fn f() {} ``` Gets collapsed into a single doc string of @@ -68,7 +70,7 @@ This is the second line. This removes documentation for any non-public items, so for example: -```rust,ignore +```rust,no_run /// These are private docs. struct Private; diff --git a/src/doc/rustdoc/src/references.md b/src/doc/rustdoc/src/references.md index 1e050e321d2..b0e2437392c 100644 --- a/src/doc/rustdoc/src/references.md +++ b/src/doc/rustdoc/src/references.md @@ -3,7 +3,7 @@ There are many great `rustdoc` references out there. If you know of other great resources, please submit a pull request! -## Official +## Official - [Learn Rust] - [Rust By Example] @@ -11,7 +11,7 @@ If you know of other great resources, please submit a pull request! - [RFC 1574: More API Documentation Conventions] - [RFC 1946: Intra Rustdoc Links] -## Community +## Community - [API Guidelines] - [Github tagged RFCs] - [Github tagged issues] @@ -28,4 +28,4 @@ If you know of other great resources, please submit a pull request! [RFC 1946: Intra Rustdoc Links]: https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html [RFC (stalled) front page styleguide]: https://github.com/rust-lang/rfcs/pull/1687 [Rust By Example]: https://doc.rust-lang.org/stable/rust-by-example/meta/doc.html -[Rust Reference]: https://doc.rust-lang.org/stable/reference/comments.html#doc-comments \ No newline at end of file +[Rust Reference]: https://doc.rust-lang.org/stable/reference/comments.html#doc-comments diff --git a/src/doc/rustdoc/src/the-doc-attribute.md b/src/doc/rustdoc/src/the-doc-attribute.md index ef143c8727e..52f2a3728fa 100644 --- a/src/doc/rustdoc/src/the-doc-attribute.md +++ b/src/doc/rustdoc/src/the-doc-attribute.md @@ -7,9 +7,10 @@ The most basic function of `#[doc]` is to handle the actual documentation text. That is, `///` is syntax sugar for `#[doc]`. This means that these two are the same: -```rust,ignore +```rust,no_run /// This is a doc comment. #[doc = " This is a doc comment."] +# fn f() {} ``` (Note the leading space in the attribute version.) @@ -18,16 +19,18 @@ In most cases, `///` is easier to use than `#[doc]`. One case where the latter i when generating documentation in macros; the `collapse-docs` pass will combine multiple `#[doc]` attributes into a single doc comment, letting you generate code like this: -```rust,ignore +```rust,no_run #[doc = "This is"] #[doc = " a "] #[doc = "doc comment"] +# fn f() {} ``` Which can feel more flexible. Note that this would generate this: -```rust,ignore +```rust,no_run #[doc = "This is\n a \ndoc comment"] +# fn f() {} ``` but given that docs are rendered via Markdown, it will remove these newlines. @@ -45,7 +48,7 @@ These options control how the docs look at a crate level. This form of the `doc` attribute lets you control the favicon of your docs. -```rust,ignore +```rust,no_run #![doc(html_favicon_url = "https://example.com/favicon.ico")] ``` @@ -59,7 +62,7 @@ If you don't use this attribute, there will be no favicon. This form of the `doc` attribute lets you control the logo in the upper left hand side of the docs. -```rust,ignore +```rust,no_run #![doc(html_logo_url = "https://example.com/logo.jpg")] ``` @@ -73,7 +76,7 @@ If you don't use this attribute, there will be no logo. This form of the `doc` attribute lets you control where the "run" buttons on your documentation examples make requests to. -```rust,ignore +```rust,no_run #![doc(html_playground_url = "https://playground.example.com/")] ``` @@ -88,7 +91,7 @@ When a feature is unstable, an issue number for tracking the feature must be given. `rustdoc` uses this number, plus the base URL given here, to link to the tracking issue. -```rust,ignore +```rust,no_run #![doc(issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/")] ``` @@ -103,7 +106,7 @@ available. If that is not available, then it will use the `html_root_url` value in the extern crate if it is available. If that is not available, then the extern items will not be linked. -```rust,ignore +```rust,no_run #![doc(html_root_url = "https://docs.rs/serde/1.0")] ``` @@ -112,7 +115,7 @@ the extern items will not be linked. By default, `rustdoc` will include the source code of your program, with links to it in the docs. But if you include this: -```rust,ignore +```rust,no_run #![doc(html_no_source)] ``` @@ -123,7 +126,7 @@ it will not. By default, `rustdoc` will automatically add a line with `extern crate my_crate;` into each doctest. But if you include this: -```rust,ignore +```rust,no_run #![doc(test(no_crate_inject))] ``` @@ -134,7 +137,7 @@ it will not. This form of the `doc` attribute allows you to add arbitrary attributes to all your doctests. For example, if you want your doctests to fail if they produce any warnings, you could add this: -```rust,ignore +```rust,no_run #![doc(test(attr(deny(warnings))))] ``` @@ -148,7 +151,7 @@ they are documented. These attributes are used on `use` statements, and control where the documentation shows up. For example, consider this Rust code: -```rust,ignore +```rust,no_run pub use bar::Bar; /// bar docs @@ -156,6 +159,7 @@ pub mod bar { /// the docs for Bar pub struct Bar; } +# fn main() {} ``` The documentation will generate a "Re-exports" section, and say `pub use bar::Bar;`, where @@ -163,9 +167,11 @@ The documentation will generate a "Re-exports" section, and say `pub use bar::Ba If we change the `use` line like this: -```rust,ignore +```rust,no_run #[doc(inline)] pub use bar::Bar; +# pub mod bar { pub struct Bar; } +# fn main() {} ``` Instead, `Bar` will appear in a `Structs` section, just like `Bar` was defined at the @@ -173,7 +179,7 @@ top level, rather than `pub use`'d. Let's change our original example, by making `bar` private: -```rust,ignore +```rust,no_run pub use bar::Bar; /// bar docs @@ -181,6 +187,7 @@ mod bar { /// the docs for Bar pub struct Bar; } +# fn main() {} ``` Here, because `bar` is not public, `Bar` wouldn't have its own page, so there's nowhere @@ -188,7 +195,7 @@ to link to. `rustdoc` will inline these definitions, and so we end up in the sam as the `#[doc(inline)]` above; `Bar` is in a `Structs` section, as if it were defined at the top level. If we add the `no_inline` form of the attribute: -```rust,ignore +```rust,no_run #[doc(no_inline)] pub use bar::Bar; @@ -197,6 +204,7 @@ mod bar { /// the docs for Bar pub struct Bar; } +# fn main() {} ``` Now we'll have a `Re-exports` line, and `Bar` will not link to anywhere. diff --git a/src/doc/rustdoc/src/what-is-rustdoc.md b/src/doc/rustdoc/src/what-is-rustdoc.md index 32dc1e02bb3..7a444d77c09 100644 --- a/src/doc/rustdoc/src/what-is-rustdoc.md +++ b/src/doc/rustdoc/src/what-is-rustdoc.md @@ -32,7 +32,7 @@ $ rustdoc src/lib.rs This will create a new directory, `doc`, with a website inside! In our case, the main page is located in `doc/lib/index.html`. If you open that up in a web browser, you will see a page with a search bar, and "Crate lib" at the -top, with no contents. +top, with no contents. ## Configuring rustdoc @@ -89,18 +89,18 @@ dependency=<path>/docs/target/debug/deps You can see this with `cargo doc --verbose`. It generates the correct `--crate-name` for us, as well as pointing to -`src/lib.rs`. But what about those other arguments? - - `-o` controls the *o*utput of our docs. Instead of a top-level - `doc` directory, notice that Cargo puts generated documentation under +`src/lib.rs`. But what about those other arguments? + - `-o` controls the *o*utput of our docs. Instead of a top-level + `doc` directory, notice that Cargo puts generated documentation under `target`. That is the idiomatic place for generated files in Cargo projects. - - `-L` flag helps rustdoc find the dependencies your code relies on. + - `-L` flag helps rustdoc find the dependencies your code relies on. If our project used dependencies, we would get documentation for them as well! ## Outer and inner documentation The `///` syntax is used to document the item present after it. That's why it is called an outer documentation. -There is another syntax: `//!`, which is used to document the +There is another syntax: `//!`, which is used to document the item it is present inside. It is called an inner documentation. It is often used when documenting the entire crate, because nothing comes before it: it is the root of the crate. diff --git a/src/doc/rustdoc/src/what-to-include.md b/src/doc/rustdoc/src/what-to-include.md index 878c75baae7..9683f519be1 100644 --- a/src/doc/rustdoc/src/what-to-include.md +++ b/src/doc/rustdoc/src/what-to-include.md @@ -38,10 +38,10 @@ warning: 1 warning emitted As a library author, adding the lint `#![deny(missing_docs)]` is a great way to ensure the project does not drift away from being documented well, and -`#![warn(missing_docs)]` is a good way to move towards comprehensive +`#![warn(missing_docs)]` is a good way to move towards comprehensive documentation. In addition to docs, `#![deny(missing_doc_code_examples)]` ensures each function contains a usage example. In our example above, the -warning is resolved by adding crate level documentation. +warning is resolved by adding crate level documentation. There are more lints in the upcoming chapter [Lints][rustdoc-lints]. @@ -58,7 +58,7 @@ users to figure out how to put the `async` code into their own runtime. It is preferred that `unwrap()` not be used inside an example, and some of the error handling components be hidden if they make the example too difficult to -follow. +follow. ``````text /// Example @@ -66,9 +66,9 @@ follow. /// let fourtytwo = "42".parse::<u32>()?; /// println!("{} + 10 = {}", fourtytwo, fourtytwo+10); /// ``` -`````` +`````` -When rustdoc wraps that in a main function, it will fail to compile because the +When rustdoc wraps that in a main function, it will fail to compile because the `ParseIntError` trait is not implemented. In order to help both your audience and your test suite, this example needs some additional code: @@ -81,17 +81,17 @@ and your test suite, this example needs some additional code: /// # Ok(()) /// # } /// ``` -`````` +`````` The example is the same on the doc page, but has that extra information -available to anyone trying to use your crate. More about tests in the -upcoming [Documentation tests] chapter. +available to anyone trying to use your crate. More about tests in the +upcoming [Documentation tests] chapter. ## What to Exclude Certain parts of your public interface may be included by default in the output of rustdoc. The attribute `#[doc(hidden)]` can hide implementation details -to encourage idiomatic use of the crate. +to encourage idiomatic use of the crate. For example, an internal `macro!` that makes the crate easier to implement can become a footgun for users when it appears in the public documentation. An @@ -101,11 +101,11 @@ detailed in the [API Guidelines]. ## Customizing the output It is possible to pass a custom css file to `rustdoc` and style the -documentation. +documentation. ```bash rustdoc --extend-css custom.css src/lib.rs -``` +``` A good example of using this feature to create a dark theme is documented [on this blog]. Just remember, dark theme is already included in the rustdoc output @@ -122,4 +122,4 @@ Here is an example of a new theme, [Ayu]. [API Guidelines]: https://rust-lang.github.io/api-guidelines/documentation.html#rustdoc-does-not-show-unhelpful-implementation-details-c-hidden [Documentation tests]: documentation-tests.md [on this blog]: https://blog.guillaume-gomez.fr/articles/2016-09-16+Generating+doc+with+rustdoc+and+a+custom+theme -[rustdoc-lints]: lints.md \ No newline at end of file +[rustdoc-lints]: lints.md diff --git a/src/doc/unstable-book/src/compiler-flags/codegen-backend.md b/src/doc/unstable-book/src/compiler-flags/codegen-backend.md index 878c894a6ca..3c0cd32fae1 100644 --- a/src/doc/unstable-book/src/compiler-flags/codegen-backend.md +++ b/src/doc/unstable-book/src/compiler-flags/codegen-backend.md @@ -15,7 +15,7 @@ named `__rustc_codegen_backend` with a signature of `fn() -> Box<dyn rustc_codeg See also the [`hotplug_codegen_backend`](https://github.com/rust-lang/rust/tree/master/src/test/run-make-fulldeps/hotplug_codegen_backend) test for a full example. -```rust,ignore +```rust,ignore (partial-example) use rustc_codegen_ssa::traits::CodegenBackend; struct MyBackend; diff --git a/src/doc/unstable-book/src/compiler-flags/control-flow-guard.md b/src/doc/unstable-book/src/compiler-flags/control-flow-guard.md index c43d91bf070..08c16d95f46 100644 --- a/src/doc/unstable-book/src/compiler-flags/control-flow-guard.md +++ b/src/doc/unstable-book/src/compiler-flags/control-flow-guard.md @@ -6,7 +6,7 @@ The tracking issue for this feature is: [#68793](https://github.com/rust-lang/ru The rustc flag `-Z control-flow-guard` enables the Windows [Control Flow Guard](https://docs.microsoft.com/en-us/windows/win32/secbp/control-flow-guard) (CFG) platform security feature. -CFG is an exploit mitigation designed to enforce control-flow integrity for software running on supported [Windows platforms (Windows 8.1 onwards)](https://docs.microsoft.com/en-us/windows/win32/secbp/control-flow-guard). Specifically, CFG uses runtime checks to validate the target address of every indirect call/jump before allowing the call to complete. +CFG is an exploit mitigation designed to enforce control-flow integrity for software running on supported [Windows platforms (Windows 8.1 onwards)](https://docs.microsoft.com/en-us/windows/win32/secbp/control-flow-guard). Specifically, CFG uses runtime checks to validate the target address of every indirect call/jump before allowing the call to complete. During compilation, the compiler identifies all indirect calls/jumps and adds CFG checks. It also emits metadata containing the relative addresses of all address-taken functions. At runtime, if the binary is run on a CFG-aware operating system, the loader uses the CFG metadata to generate a bitmap of the address space and marks those addresses that contain valid targets. On each indirect call, the inserted check determines whether the target address is marked in this bitmap. If the target is not valid, the process is terminated. @@ -35,7 +35,7 @@ The rustc flag `-Z control-flow-guard=nochecks` instructs LLVM to emit the list ## Control Flow Guard in libraries -It is strongly recommended to also enable CFG checks for all linked libraries, including the standard library. +It is strongly recommended to also enable CFG checks for all linked libraries, including the standard library. To enable CFG in the standard library, use the [cargo `-Z build-std` functionality][build-std] to recompile the standard library with the same configuration options as the main program. diff --git a/src/doc/unstable-book/src/compiler-flags/extern-location.md b/src/doc/unstable-book/src/compiler-flags/extern-location.md new file mode 100644 index 00000000000..1c80d5426bf --- /dev/null +++ b/src/doc/unstable-book/src/compiler-flags/extern-location.md @@ -0,0 +1,31 @@ +# `extern-location` + +MCP for this feature: [#303] + +[#303]: https://github.com/rust-lang/compiler-team/issues/303 + +------------------------ + +The `unused-extern-crates` lint reports when a crate was specified on the rustc +command-line with `--extern name=path` but no symbols were referenced in it. +This is useful to know, but it's hard to map that back to a specific place a user +or tool could fix (ie, to remove the unused dependency). + +The `--extern-location` flag allows the build system to associate a location with +the `--extern` option, which is then emitted as part of the diagnostics. This location +is abstract and just round-tripped through rustc; the compiler never attempts to +interpret it in any way. + +There are two supported forms of location: a bare string, or a blob of json: +- `--extern-location foo=raw:Makefile:123` would associate the raw string `Makefile:123` +- `--extern-location 'bar=json:{"target":"//my_project:library","dep":"//common:serde"}` would + associate the json structure with `--extern bar=<path>`, indicating which dependency of + which rule introduced the unused extern crate. + +This primarily intended to be used with tooling - for example a linter which can automatically +remove unused dependencies - rather than being directly presented to users. + +`raw` locations are presented as part of the normal rendered diagnostics and included in +the json form. `json` locations are only included in the json form of diagnostics, +as a `tool_metadata` field. For `raw` locations `tool_metadata` is simply a json string, +whereas `json` allows the rustc invoker to fully control its form and content. diff --git a/src/doc/unstable-book/src/compiler-flags/profile.md b/src/doc/unstable-book/src/compiler-flags/profile.md index 7973b3e4f2f..71303bfaff2 100644 --- a/src/doc/unstable-book/src/compiler-flags/profile.md +++ b/src/doc/unstable-book/src/compiler-flags/profile.md @@ -22,6 +22,6 @@ Once you've built and run your program, files with the `gcno` (after build) and You can parse them with [llvm-cov gcov](https://llvm.org/docs/CommandGuide/llvm-cov.html#llvm-cov-gcov) or [grcov](https://github.com/mozilla/grcov). Please note that `RUSTFLAGS` by default applies to everything that cargo builds and runs during a build! -When the `--target` flag is explicitly passed to cargo, the `RUSTFLAGS` no longer apply to build scripts and procedural macros. -For more fine-grained control consider passing a `RUSTC_WRAPPER` program to cargo that only adds the profiling flags to +When the `--target` flag is explicitly passed to cargo, the `RUSTFLAGS` no longer apply to build scripts and procedural macros. +For more fine-grained control consider passing a `RUSTC_WRAPPER` program to cargo that only adds the profiling flags to rustc for the specific crates you want to profile. diff --git a/src/doc/unstable-book/src/compiler-flags/report-time.md b/src/doc/unstable-book/src/compiler-flags/report-time.md index 68265d8a9e8..ac0093f77ae 100644 --- a/src/doc/unstable-book/src/compiler-flags/report-time.md +++ b/src/doc/unstable-book/src/compiler-flags/report-time.md @@ -34,7 +34,7 @@ Available options: Expected format of environment variable is `VARIABLE=WARN_TIME,CRITICAL_TIME`. Not available for --format=terse ---ensure-time +--ensure-time Treat excess of the test execution time limit as error. Threshold values for this option can be configured via diff --git a/src/doc/unstable-book/src/compiler-flags/tls-model.md b/src/doc/unstable-book/src/compiler-flags/tls-model.md index cd625f3fd09..8b19e785c6a 100644 --- a/src/doc/unstable-book/src/compiler-flags/tls-model.md +++ b/src/doc/unstable-book/src/compiler-flags/tls-model.md @@ -11,7 +11,7 @@ Supported values for this option are: - `global-dynamic` - General Dynamic TLS Model (alternatively called Global Dynamic) is the most general option usable in all circumstances, even if the TLS data is defined in a shared library -loaded at runtime and is accessed from code outside of that library. +loaded at runtime and is accessed from code outside of that library. This is the default for most targets. - `local-dynamic` - model usable if the TLS data is only accessed from the shared library or executable it is defined in. The TLS data may be in a library loaded after startup (via `dlopen`). diff --git a/src/doc/unstable-book/src/language-features/auto-traits.md b/src/doc/unstable-book/src/language-features/auto-traits.md index 0ca6dd6670b..f967c11fc4d 100644 --- a/src/doc/unstable-book/src/language-features/auto-traits.md +++ b/src/doc/unstable-book/src/language-features/auto-traits.md @@ -1,6 +1,6 @@ # `auto_traits` -The tracking issue for this feature is [#13231] +The tracking issue for this feature is [#13231] [#13231]: https://github.com/rust-lang/rust/issues/13231 @@ -9,15 +9,15 @@ The tracking issue for this feature is [#13231] The `auto_traits` feature gate allows you to define auto traits. Auto traits, like [`Send`] or [`Sync`] in the standard library, are marker traits -that are automatically implemented for every type, unless the type, or a type it contains, +that are automatically implemented for every type, unless the type, or a type it contains, has explicitly opted out via a negative impl. (Negative impls are separately controlled by the `negative_impls` feature.) [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html -```rust,ignore -impl !Trait for Type +```rust,ignore (partial-example) +impl !Trait for Type {} ``` Example: @@ -40,7 +40,7 @@ fn must_be_valid<T: Valid>(_t: T) { } fn main() { // works must_be_valid( MaybeValid(True) ); - + // compiler error - trait bound not satisfied // must_be_valid( MaybeValid(False) ); } @@ -80,7 +80,7 @@ where Explicit impls may be either positive or negative. They take the form: -```rust,ignore +```rust,ignore (partial-example) impl<...> AutoTrait for StructName<..> { } impl<...> !AutoTrait for StructName<..> { } ``` @@ -104,4 +104,3 @@ Auto traits cannot have any trait items, such as methods or associated types. Th ## Supertraits Auto traits cannot have supertraits. This is for soundness reasons, as the interaction of coinduction with implied bounds is difficult to reconcile. - diff --git a/src/doc/unstable-book/src/language-features/custom-test-frameworks.md b/src/doc/unstable-book/src/language-features/custom-test-frameworks.md index 3990b6ad2f0..53ecac9314d 100644 --- a/src/doc/unstable-book/src/language-features/custom-test-frameworks.md +++ b/src/doc/unstable-book/src/language-features/custom-test-frameworks.md @@ -30,4 +30,3 @@ const WILL_PASS: i32 = 0; #[test_case] const WILL_FAIL: i32 = 4; ``` - diff --git a/src/doc/unstable-book/src/language-features/infer-static-outlives-requirements.md b/src/doc/unstable-book/src/language-features/infer-static-outlives-requirements.md index 53e01091f75..5f3f1b4dd8a 100644 --- a/src/doc/unstable-book/src/language-features/infer-static-outlives-requirements.md +++ b/src/doc/unstable-book/src/language-features/infer-static-outlives-requirements.md @@ -42,4 +42,3 @@ struct Bar<T: 'static> { x: T, } ``` - diff --git a/src/doc/unstable-book/src/language-features/intrinsics.md b/src/doc/unstable-book/src/language-features/intrinsics.md index bc35c2a0305..a0fb4e743d3 100644 --- a/src/doc/unstable-book/src/language-features/intrinsics.md +++ b/src/doc/unstable-book/src/language-features/intrinsics.md @@ -27,4 +27,3 @@ extern "rust-intrinsic" { ``` As with any other FFI functions, these are always `unsafe` to call. - diff --git a/src/doc/unstable-book/src/language-features/lang-items.md b/src/doc/unstable-book/src/language-features/lang-items.md index 20c7d7dcec8..d44c841d48c 100644 --- a/src/doc/unstable-book/src/language-features/lang-items.md +++ b/src/doc/unstable-book/src/language-features/lang-items.md @@ -15,8 +15,8 @@ For example, `Box` pointers require two lang items, one for allocation and one for deallocation. A freestanding program that uses the `Box` sugar for dynamic allocations via `malloc` and `free`: -```rust,ignore -#![feature(lang_items, box_syntax, start, libc, core_intrinsics)] +```rust,ignore (libc-is-finicky) +#![feature(lang_items, box_syntax, start, libc, core_intrinsics, rustc_private)] #![no_std] use core::intrinsics; use core::panic::PanicInfo; @@ -105,8 +105,8 @@ or overriding the default shim for the C `main` function with your own. The function marked `#[start]` is passed the command line parameters in the same format as C: -```rust,ignore -#![feature(lang_items, core_intrinsics)] +```rust,ignore (libc-is-finicky) +#![feature(lang_items, core_intrinsics, rustc_private)] #![feature(start)] #![no_std] use core::intrinsics; @@ -141,8 +141,8 @@ with `#![no_main]` and then create the appropriate symbol with the correct ABI and the correct name, which requires overriding the compiler's name mangling too: -```rust,ignore -#![feature(lang_items, core_intrinsics)] +```rust,ignore (libc-is-finicky) +#![feature(lang_items, core_intrinsics, rustc_private)] #![feature(start)] #![no_std] #![no_main] diff --git a/src/doc/unstable-book/src/language-features/non-ascii-idents.md b/src/doc/unstable-book/src/language-features/non-ascii-idents.md index 22dae0c89a6..847f25ecab1 100644 --- a/src/doc/unstable-book/src/language-features/non-ascii-idents.md +++ b/src/doc/unstable-book/src/language-features/non-ascii-idents.md @@ -19,10 +19,10 @@ const Π: f64 = 3.14f64; ## Changes to the language reference -> **<sup>Lexer:<sup>** -> IDENTIFIER : -> XID_start XID_continue<sup>\*</sup> -> | `_` XID_continue<sup>+</sup> +> **<sup>Lexer:<sup>**\ +> IDENTIFIER :\ +> XID_start XID_continue<sup>\*</sup>\ +> | `_` XID_continue<sup>+</sup> An identifier is any nonempty Unicode string of the following form: diff --git a/src/doc/unstable-book/src/language-features/or-patterns.md b/src/doc/unstable-book/src/language-features/or-patterns.md index 8ebacb44d37..55c31add26d 100644 --- a/src/doc/unstable-book/src/language-features/or-patterns.md +++ b/src/doc/unstable-book/src/language-features/or-patterns.md @@ -11,7 +11,7 @@ a pattern, for example, `Some(A(0) | B(1 | 2))` becomes a valid pattern. ## Examples -```rust,ignore +```rust,no_run #![feature(or_patterns)] pub enum Foo { diff --git a/src/doc/unstable-book/src/language-features/plugin.md b/src/doc/unstable-book/src/language-features/plugin.md index 38351131527..44308bdfba6 100644 --- a/src/doc/unstable-book/src/language-features/plugin.md +++ b/src/doc/unstable-book/src/language-features/plugin.md @@ -38,7 +38,7 @@ additional checks for code style, safety, etc. Now let's write a plugin [`lint-plugin-test.rs`](https://github.com/rust-lang/rust/blob/master/src/test/ui-fulldeps/auxiliary/lint-plugin-test.rs) that warns about any item named `lintme`. -```rust,ignore +```rust,ignore (requires-stage-2) #![feature(plugin_registrar)] #![feature(box_syntax, rustc_private)] @@ -77,7 +77,7 @@ pub fn plugin_registrar(reg: &mut Registry) { Then code like -```rust,ignore +```rust,ignore (requires-plugin) #![feature(plugin)] #![plugin(lint_plugin_test)] diff --git a/src/doc/unstable-book/src/language-features/rustc-attrs.md b/src/doc/unstable-book/src/language-features/rustc-attrs.md index 1d9409ee9e4..c67b806f06a 100644 --- a/src/doc/unstable-book/src/language-features/rustc-attrs.md +++ b/src/doc/unstable-book/src/language-features/rustc-attrs.md @@ -18,7 +18,7 @@ Options provided by `#[rustc_layout(...)]` are `debug`, `size`, `align`, ## Examples -```rust,ignore +```rust,compile_fail #![feature(rustc_attrs)] #[rustc_layout(abi, size)] diff --git a/src/doc/unstable-book/src/language-features/unboxed-closures.md b/src/doc/unstable-book/src/language-features/unboxed-closures.md index 71003fba00b..e4113d72d09 100644 --- a/src/doc/unstable-book/src/language-features/unboxed-closures.md +++ b/src/doc/unstable-book/src/language-features/unboxed-closures.md @@ -9,7 +9,7 @@ See Also: [`fn_traits`](../library-features/fn-traits.md) ---- The `unboxed_closures` feature allows you to write functions using the `"rust-call"` ABI, -required for implementing the [`Fn*`] family of traits. `"rust-call"` functions must have +required for implementing the [`Fn*`] family of traits. `"rust-call"` functions must have exactly one (non self) argument, a tuple representing the argument list. [`Fn*`]: https://doc.rust-lang.org/std/ops/trait.Fn.html diff --git a/src/doc/unstable-book/src/language-features/unsized-locals.md b/src/doc/unstable-book/src/language-features/unsized-locals.md index d716b1d51dc..d5b01a3d616 100644 --- a/src/doc/unstable-book/src/language-features/unsized-locals.md +++ b/src/doc/unstable-book/src/language-features/unsized-locals.md @@ -30,7 +30,7 @@ fn foo(_: dyn Any) {} The RFC still forbids the following unsized expressions: -```rust,ignore +```rust,compile_fail #![feature(unsized_locals)] use std::any::Any; @@ -124,7 +124,7 @@ One of the objectives of this feature is to allow `Box<dyn FnOnce>`. The RFC also describes an extension to the array literal syntax: `[e; dyn n]`. In the syntax, `n` isn't necessarily a constant expression. The array is dynamically allocated on the stack and has the type of `[T]`, instead of `[T; n]`. -```rust,ignore +```rust,ignore (not-yet-implemented) #![feature(unsized_locals)] fn mergesort<T: Ord>(a: &mut [T]) { diff --git a/src/doc/unstable-book/src/language-features/unsized-tuple-coercion.md b/src/doc/unstable-book/src/language-features/unsized-tuple-coercion.md index 731d2acbfdd..310c8d96294 100644 --- a/src/doc/unstable-book/src/language-features/unsized-tuple-coercion.md +++ b/src/doc/unstable-book/src/language-features/unsized-tuple-coercion.md @@ -8,7 +8,7 @@ The tracking issue for this feature is: [#42877] This is a part of [RFC0401]. According to the RFC, there should be an implementation like this: -```rust,ignore +```rust,ignore (partial-example) impl<..., T, U: ?Sized> Unsized<(..., U)> for (..., T) where T: Unsized<U> {} ``` diff --git a/src/doc/unstable-book/src/library-features/asm.md b/src/doc/unstable-book/src/library-features/asm.md index ccdd8628699..c0e23b834d1 100644 --- a/src/doc/unstable-book/src/library-features/asm.md +++ b/src/doc/unstable-book/src/library-features/asm.md @@ -405,7 +405,7 @@ When required, options are specified as the final argument. The following ABNF specifies the general syntax: -```ignore +```text dir_spec := "in" / "out" / "lateout" / "inout" / "inlateout" reg_spec := <register class> / "<explicit register>" operand_expr := expr / "_" / expr "=>" expr / expr "=>" "_" diff --git a/src/doc/unstable-book/src/library-features/concat-idents.md b/src/doc/unstable-book/src/library-features/concat-idents.md index ecfd34a22e5..73f6cfa2178 100644 --- a/src/doc/unstable-book/src/library-features/concat-idents.md +++ b/src/doc/unstable-book/src/library-features/concat-idents.md @@ -19,4 +19,4 @@ fn main() { let f = concat_idents!(foo, bar); assert_eq!(f(), 23); } -``` \ No newline at end of file +``` diff --git a/src/doc/unstable-book/src/library-features/global-asm.md b/src/doc/unstable-book/src/library-features/global-asm.md index bc55fe80fa6..ce1155a977c 100644 --- a/src/doc/unstable-book/src/library-features/global-asm.md +++ b/src/doc/unstable-book/src/library-features/global-asm.md @@ -24,17 +24,18 @@ conventions of the assembler in your toolchain. A simple usage looks like this: -```rust,ignore -# #![feature(global_asm)] -# you also need relevant target_arch cfgs +```rust,ignore (requires-external-file) +#![feature(global_asm)] +# // you also need relevant target_arch cfgs global_asm!(include_str!("something_neato.s")); ``` And a more complicated usage looks like this: -```rust,ignore -# #![feature(global_asm)] -# #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] +```rust,no_run +#![feature(global_asm)] +# #[cfg(any(target_arch="x86", target_arch="x86_64"))] +# mod x86 { pub mod sally { global_asm!(r#" @@ -64,6 +65,7 @@ pub mod harry { #[no_mangle] pub unsafe extern "C" fn quux() {} } +# } ``` You may use `global_asm!` multiple times, anywhere in your crate, in diff --git a/src/doc/unstable-book/src/library-features/llvm-asm.md b/src/doc/unstable-book/src/library-features/llvm-asm.md index a2f029db291..07fc16261d8 100644 --- a/src/doc/unstable-book/src/library-features/llvm-asm.md +++ b/src/doc/unstable-book/src/library-features/llvm-asm.md @@ -10,7 +10,7 @@ For extremely low-level manipulations and performance reasons, one might wish to control the CPU directly. Rust supports using inline assembly to do this via the `llvm_asm!` macro. -```rust,ignore +```rust,ignore (pseudo-code) llvm_asm!(assembly template : output operands : input operands diff --git a/src/doc/unstable-book/src/library-features/test.md b/src/doc/unstable-book/src/library-features/test.md index 6b4a3a677db..c99584e5fb3 100644 --- a/src/doc/unstable-book/src/library-features/test.md +++ b/src/doc/unstable-book/src/library-features/test.md @@ -9,7 +9,7 @@ most widely used part of the `test` crate are benchmark tests, which can test the performance of your code. Let's make our `src/lib.rs` look like this (comments elided): -```rust,ignore +```rust,no_run #![feature(test)] extern crate test; @@ -83,7 +83,7 @@ the benchmark is no longer benchmarking what one expects. For example, the compiler might recognize that some calculation has no external effects and remove it entirely. -```rust,ignore +```rust,no_run #![feature(test)] extern crate test; diff --git a/src/doc/unstable-book/src/library-features/try-trait.md b/src/doc/unstable-book/src/library-features/try-trait.md index 0c07329025b..022640067bd 100644 --- a/src/doc/unstable-book/src/library-features/try-trait.md +++ b/src/doc/unstable-book/src/library-features/try-trait.md @@ -16,7 +16,7 @@ macro on `Poll`, among other things. Here's an example implementation of the trait: -```rust,ignore +```rust,ignore (cannot-reimpl-Try) /// A distinct type to represent the `None` value of an `Option`. /// /// This enables using the `?` operator on `Option`; it's rarely useful alone. diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 2588c00f2cf..cdff37cbd51 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -217,13 +217,10 @@ fn build_external_function(cx: &DocContext<'_>, did: DefId) -> clean::Function { let (generics, decl) = clean::enter_impl_trait(cx, || { ((cx.tcx.generics_of(did), predicates).clean(cx), (did, sig).clean(cx)) }); - let (all_types, ret_types) = clean::get_all_types(&generics, &decl, cx); clean::Function { decl, generics, header: hir::FnHeader { unsafety: sig.unsafety(), abi: sig.abi(), constness, asyncness }, - all_types, - ret_types, } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 03454bb8b7f..331bb2a73f9 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -928,8 +928,7 @@ impl<'a> Clean<Function> for (&'a hir::FnSig<'a>, &'a hir::Generics<'a>, hir::Bo fn clean(&self, cx: &DocContext<'_>) -> Function { let (generics, decl) = enter_impl_trait(cx, || (self.1.clean(cx), (&*self.0.decl, self.2).clean(cx))); - let (all_types, ret_types) = get_all_types(&generics, &decl, cx); - Function { decl, generics, header: self.0.header, all_types, ret_types } + Function { decl, generics, header: self.0.header } } } @@ -1043,21 +1042,7 @@ impl Clean<PolyTrait> for hir::PolyTraitRef<'_> { impl Clean<TypeKind> for hir::def::DefKind { fn clean(&self, _: &DocContext<'_>) -> TypeKind { - match *self { - hir::def::DefKind::Mod => TypeKind::Module, - hir::def::DefKind::Struct => TypeKind::Struct, - hir::def::DefKind::Union => TypeKind::Union, - hir::def::DefKind::Enum => TypeKind::Enum, - hir::def::DefKind::Trait => TypeKind::Trait, - hir::def::DefKind::TyAlias => TypeKind::Typedef, - hir::def::DefKind::ForeignTy => TypeKind::Foreign, - hir::def::DefKind::TraitAlias => TypeKind::TraitAlias, - hir::def::DefKind::Fn => TypeKind::Function, - hir::def::DefKind::Const => TypeKind::Const, - hir::def::DefKind::Static => TypeKind::Static, - hir::def::DefKind::Macro(_) => TypeKind::Macro, - _ => TypeKind::Foreign, - } + (*self).into() } } @@ -1082,9 +1067,7 @@ impl Clean<Item> for hir::TraitItem<'_> { let (generics, decl) = enter_impl_trait(cx, || { (self.generics.clean(cx), (&*sig.decl, &names[..]).clean(cx)) }); - let (all_types, ret_types) = get_all_types(&generics, &decl, cx); - let mut t = - Function { header: sig.header, decl, generics, all_types, ret_types }; + let mut t = Function { header: sig.header, decl, generics }; if t.header.constness == hir::Constness::Const && is_unstable_const_fn(cx.tcx, local_did).is_some() { @@ -1196,7 +1179,6 @@ impl Clean<Item> for ty::AssocItem { ty::ImplContainer(_) => true, ty::TraitContainer(_) => self.defaultness.has_value(), }; - let (all_types, ret_types) = get_all_types(&generics, &decl, cx); if provided { let constness = if is_min_const_fn(cx.tcx, self.def_id) { hir::Constness::Const @@ -1218,8 +1200,6 @@ impl Clean<Item> for ty::AssocItem { constness, asyncness, }, - all_types, - ret_types, }, defaultness, ) @@ -1233,8 +1213,6 @@ impl Clean<Item> for ty::AssocItem { constness: hir::Constness::NotConst, asyncness: hir::IsAsync::NotAsync, }, - all_types, - ret_types, }) } } @@ -2274,7 +2252,6 @@ impl Clean<Item> for (&hir::ForeignItem<'_>, Option<Symbol>) { let (generics, decl) = enter_impl_trait(cx, || { (generics.clean(cx), (&**decl, &names[..]).clean(cx)) }); - let (all_types, ret_types) = get_all_types(&generics, &decl, cx); ForeignFunctionItem(Function { decl, generics, @@ -2284,8 +2261,6 @@ impl Clean<Item> for (&hir::ForeignItem<'_>, Option<Symbol>) { constness: hir::Constness::NotConst, asyncness: hir::IsAsync::NotAsync, }, - all_types, - ret_types, }) } hir::ForeignItemKind::Static(ref ty, mutability) => ForeignStaticItem(Static { diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index e509ec3f021..754f1c2eeeb 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -1087,8 +1087,6 @@ crate struct Function { crate decl: FnDecl, crate generics: Generics, crate header: hir::FnHeader, - crate all_types: Vec<(Type, TypeKind)>, - crate ret_types: Vec<(Type, TypeKind)>, } #[derive(Clone, PartialEq, Eq, Debug, Hash)] @@ -1304,6 +1302,43 @@ crate enum TypeKind { Primitive, } +impl From<hir::def::DefKind> for TypeKind { + fn from(other: hir::def::DefKind) -> Self { + match other { + hir::def::DefKind::Enum => Self::Enum, + hir::def::DefKind::Fn => Self::Function, + hir::def::DefKind::Mod => Self::Module, + hir::def::DefKind::Const => Self::Const, + hir::def::DefKind::Static => Self::Static, + hir::def::DefKind::Struct => Self::Struct, + hir::def::DefKind::Union => Self::Union, + hir::def::DefKind::Trait => Self::Trait, + hir::def::DefKind::TyAlias => Self::Typedef, + hir::def::DefKind::TraitAlias => Self::TraitAlias, + hir::def::DefKind::Macro(_) => Self::Macro, + hir::def::DefKind::ForeignTy + | hir::def::DefKind::Variant + | hir::def::DefKind::AssocTy + | hir::def::DefKind::TyParam + | hir::def::DefKind::ConstParam + | hir::def::DefKind::Ctor(..) + | hir::def::DefKind::AssocFn + | hir::def::DefKind::AssocConst + | hir::def::DefKind::ExternCrate + | hir::def::DefKind::Use + | hir::def::DefKind::ForeignMod + | hir::def::DefKind::AnonConst + | hir::def::DefKind::OpaqueTy + | hir::def::DefKind::Field + | hir::def::DefKind::LifetimeParam + | hir::def::DefKind::GlobalAsm + | hir::def::DefKind::Impl + | hir::def::DefKind::Closure + | hir::def::DefKind::Generator => Self::Foreign, + } + } +} + crate trait GetDefId { /// Use this method to get the [`DefId`] of a [`clean`] AST node. /// This will return [`None`] when called on a primitive [`clean::Type`]. @@ -1367,14 +1402,14 @@ impl Type { } } - crate fn generics(&self) -> Option<Vec<Type>> { + crate fn generics(&self) -> Option<Vec<&Type>> { match *self { ResolvedPath { ref path, .. } => path.segments.last().and_then(|seg| { if let GenericArgs::AngleBracketed { ref args, .. } = seg.args { Some( args.iter() .filter_map(|arg| match arg { - GenericArg::Type(ty) => Some(ty.clone()), + GenericArg::Type(ty) => Some(ty), _ => None, }) .collect(), diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index e380d4672d0..2c829c49953 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -1,10 +1,9 @@ use crate::clean::auto_trait::AutoTraitFinder; use crate::clean::blanket_impl::BlanketImplFinder; use crate::clean::{ - inline, Clean, Crate, ExternalCrate, FnDecl, FnRetTy, Generic, GenericArg, GenericArgs, - GenericBound, Generics, GetDefId, ImportSource, Item, ItemKind, Lifetime, MacroKind, Path, - PathSegment, Primitive, PrimitiveType, ResolvedPath, Type, TypeBinding, TypeKind, - WherePredicate, + inline, Clean, Crate, ExternalCrate, Generic, GenericArg, GenericArgs, ImportSource, Item, + ItemKind, Lifetime, MacroKind, Path, PathSegment, Primitive, PrimitiveType, ResolvedPath, Type, + TypeBinding, TypeKind, }; use crate::core::DocContext; @@ -160,125 +159,6 @@ pub(super) fn external_path( } } -/// The point of this function is to replace bounds with types. -/// -/// i.e. `[T, U]` when you have the following bounds: `T: Display, U: Option<T>` will return -/// `[Display, Option]` (we just returns the list of the types, we don't care about the -/// wrapped types in here). -crate fn get_real_types( - generics: &Generics, - arg: &Type, - cx: &DocContext<'_>, - recurse: i32, -) -> FxHashSet<(Type, TypeKind)> { - fn insert(res: &mut FxHashSet<(Type, TypeKind)>, cx: &DocContext<'_>, ty: Type) { - if let Some(kind) = ty.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) { - res.insert((ty, kind)); - } else if ty.is_primitive() { - // This is a primitive, let's store it as such. - res.insert((ty, TypeKind::Primitive)); - } - } - let mut res = FxHashSet::default(); - if recurse >= 10 { - // FIXME: remove this whole recurse thing when the recursion bug is fixed - return res; - } - - if arg.is_full_generic() { - let arg_s = Symbol::intern(&arg.print(&cx.cache).to_string()); - if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g { - WherePredicate::BoundPredicate { ty, .. } => ty.def_id() == arg.def_id(), - _ => false, - }) { - let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]); - for bound in bounds.iter() { - if let GenericBound::TraitBound(poly_trait, _) = bound { - for x in poly_trait.generic_params.iter() { - if !x.is_type() { - continue; - } - if let Some(ty) = x.get_type() { - let adds = get_real_types(generics, &ty, cx, recurse + 1); - if !adds.is_empty() { - res.extend(adds); - } else if !ty.is_full_generic() { - insert(&mut res, cx, ty); - } - } - } - } - } - } - if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) { - for bound in bound.get_bounds().unwrap_or_else(|| &[]) { - if let Some(ty) = bound.get_trait_type() { - let adds = get_real_types(generics, &ty, cx, recurse + 1); - if !adds.is_empty() { - res.extend(adds); - } else if !ty.is_full_generic() { - insert(&mut res, cx, ty); - } - } - } - } - } else { - insert(&mut res, cx, arg.clone()); - if let Some(gens) = arg.generics() { - for gen in gens.iter() { - if gen.is_full_generic() { - let adds = get_real_types(generics, gen, cx, recurse + 1); - if !adds.is_empty() { - res.extend(adds); - } - } else { - insert(&mut res, cx, gen.clone()); - } - } - } - } - res -} - -/// Return the full list of types when bounds have been resolved. -/// -/// i.e. `fn foo<A: Display, B: Option<A>>(x: u32, y: B)` will return -/// `[u32, Display, Option]`. -crate fn get_all_types( - generics: &Generics, - decl: &FnDecl, - cx: &DocContext<'_>, -) -> (Vec<(Type, TypeKind)>, Vec<(Type, TypeKind)>) { - let mut all_types = FxHashSet::default(); - for arg in decl.inputs.values.iter() { - if arg.type_.is_self_type() { - continue; - } - let args = get_real_types(generics, &arg.type_, cx, 0); - if !args.is_empty() { - all_types.extend(args); - } else { - if let Some(kind) = arg.type_.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) { - all_types.insert((arg.type_.clone(), kind)); - } - } - } - - let ret_types = match decl.output { - FnRetTy::Return(ref return_type) => { - let mut ret = get_real_types(generics, &return_type, cx, 0); - if ret.is_empty() { - if let Some(kind) = return_type.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) { - ret.insert((return_type.clone(), kind)); - } - } - ret.into_iter().collect() - } - _ => Vec::new(), - }; - (all_types.into_iter().collect(), ret_types) -} - crate fn strip_type(ty: Type) -> Type { match ty { Type::ResolvedPath { path, param_names, did, is_generic } => { diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index aa18684aea1..a20e9dec33b 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -435,7 +435,7 @@ crate fn create_resolver<'a>( // Before we actually clone it, let's force all the extern'd crates to // actually be loaded, just in case they're only referred to inside - // intra-doc-links + // intra-doc links resolver.borrow_mut().access(|resolver| { sess.time("load_extern_crates", || { for extern_name in &extern_names { diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs index 30ff124dac6..eecfd337cdf 100644 --- a/src/librustdoc/doctest.rs +++ b/src/librustdoc/doctest.rs @@ -296,7 +296,12 @@ fn run_test( } }); if let ErrorOutputType::HumanReadable(kind) = options.error_format { - let (_, color_config) = kind.unzip(); + let (short, color_config) = kind.unzip(); + + if short { + compiler.arg("--error-format").arg("short"); + } + match color_config { ColorConfig::Never => { compiler.arg("--color").arg("never"); diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs index c506f5a37b1..ce1204c7be1 100644 --- a/src/librustdoc/formats/cache.rs +++ b/src/librustdoc/formats/cache.rs @@ -5,6 +5,7 @@ use std::path::{Path, PathBuf}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX}; use rustc_middle::middle::privacy::AccessLevels; +use rustc_middle::ty::TyCtxt; use rustc_span::source_map::FileName; use rustc_span::Symbol; @@ -121,13 +122,21 @@ crate struct Cache { crate aliases: BTreeMap<String, Vec<usize>>, } +/// This struct is used to wrap the `cache` and `tcx` in order to run `DocFolder`. +struct CacheBuilder<'a, 'tcx> { + cache: &'a mut Cache, + empty_cache: Cache, + tcx: TyCtxt<'tcx>, +} + impl Cache { - crate fn from_krate( + crate fn from_krate<'tcx>( render_info: RenderInfo, document_private: bool, extern_html_root_urls: &BTreeMap<String, String>, dst: &Path, mut krate: clean::Crate, + tcx: TyCtxt<'tcx>, ) -> (clean::Crate, Cache) { // Crawl the crate to build various caches used for the output let RenderInfo { @@ -194,7 +203,8 @@ impl Cache { cache.stack.push(krate.name.to_string()); - krate = cache.fold_crate(krate); + krate = CacheBuilder { tcx, cache: &mut cache, empty_cache: Cache::default() } + .fold_crate(krate); for (trait_did, dids, impl_) in cache.orphan_trait_impls.drain(..) { if cache.traits.contains_key(&trait_did) { @@ -208,7 +218,7 @@ impl Cache { } } -impl DocFolder for Cache { +impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> { fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> { if item.def_id.is_local() { debug!("folding {} \"{:?}\", id {:?}", item.type_(), item.name, item.def_id); @@ -218,17 +228,17 @@ impl DocFolder for Cache { // we don't want it or its children in the search index. let orig_stripped_mod = match *item.kind { clean::StrippedItem(box clean::ModuleItem(..)) => { - mem::replace(&mut self.stripped_mod, true) + mem::replace(&mut self.cache.stripped_mod, true) } - _ => self.stripped_mod, + _ => self.cache.stripped_mod, }; // If the impl is from a masked crate or references something from a // masked crate then remove it completely. if let clean::ImplItem(ref i) = *item.kind { - if self.masked_crates.contains(&item.def_id.krate) - || i.trait_.def_id().map_or(false, |d| self.masked_crates.contains(&d.krate)) - || i.for_.def_id().map_or(false, |d| self.masked_crates.contains(&d.krate)) + if self.cache.masked_crates.contains(&item.def_id.krate) + || i.trait_.def_id().map_or(false, |d| self.cache.masked_crates.contains(&d.krate)) + || i.for_.def_id().map_or(false, |d| self.cache.masked_crates.contains(&d.krate)) { return None; } @@ -237,14 +247,15 @@ impl DocFolder for Cache { // Propagate a trait method's documentation to all implementors of the // trait. if let clean::TraitItem(ref t) = *item.kind { - self.traits.entry(item.def_id).or_insert_with(|| t.clone()); + self.cache.traits.entry(item.def_id).or_insert_with(|| t.clone()); } // Collect all the implementors of traits. if let clean::ImplItem(ref i) = *item.kind { if let Some(did) = i.trait_.def_id() { if i.blanket_impl.is_none() { - self.implementors + self.cache + .implementors .entry(did) .or_default() .push(Impl { impl_item: item.clone() }); @@ -257,7 +268,7 @@ impl DocFolder for Cache { let (parent, is_inherent_impl_item) = match *item.kind { clean::StrippedItem(..) => ((None, None), false), clean::AssocConstItem(..) | clean::TypedefItem(_, true) - if self.parent_is_trait_impl => + if self.cache.parent_is_trait_impl => { // skip associated items in trait impls ((None, None), false) @@ -267,18 +278,18 @@ impl DocFolder for Cache { | clean::StructFieldItem(..) | clean::VariantItem(..) => ( ( - Some(*self.parent_stack.last().expect("parent_stack is empty")), - Some(&self.stack[..self.stack.len() - 1]), + Some(*self.cache.parent_stack.last().expect("parent_stack is empty")), + Some(&self.cache.stack[..self.cache.stack.len() - 1]), ), false, ), clean::MethodItem(..) | clean::AssocConstItem(..) => { - if self.parent_stack.is_empty() { + if self.cache.parent_stack.is_empty() { ((None, None), false) } else { - let last = self.parent_stack.last().expect("parent_stack is empty 2"); + let last = self.cache.parent_stack.last().expect("parent_stack is empty 2"); let did = *last; - let path = match self.paths.get(&did) { + let path = match self.cache.paths.get(&did) { // The current stack not necessarily has correlation // for where the type was defined. On the other // hand, `paths` always has the right @@ -290,24 +301,24 @@ impl DocFolder for Cache { | ItemType::Union | ItemType::Enum, )) => Some(&fqp[..fqp.len() - 1]), - Some(..) => Some(&*self.stack), + Some(..) => Some(&*self.cache.stack), None => None, }; ((Some(*last), path), true) } } - _ => ((None, Some(&*self.stack)), false), + _ => ((None, Some(&*self.cache.stack)), false), }; match parent { - (parent, Some(path)) if is_inherent_impl_item || !self.stripped_mod => { + (parent, Some(path)) if is_inherent_impl_item || !self.cache.stripped_mod => { debug_assert!(!item.is_stripped()); // A crate has a module at its root, containing all items, // which should not be indexed. The crate-item itself is // inserted later on when serializing the search-index. if item.def_id.index != CRATE_DEF_INDEX { - self.search_index.push(IndexItem { + self.cache.search_index.push(IndexItem { ty: item.type_(), name: s.to_string(), path: path.join("::"), @@ -316,21 +327,22 @@ impl DocFolder for Cache { .map_or_else(String::new, |x| short_markdown_summary(&x.as_str())), parent, parent_idx: None, - search_type: get_index_search_type(&item, None), + search_type: get_index_search_type(&item, &self.empty_cache, self.tcx), }); for alias in item.attrs.get_doc_aliases() { - self.aliases + self.cache + .aliases .entry(alias.to_lowercase()) .or_insert(Vec::new()) - .push(self.search_index.len() - 1); + .push(self.cache.search_index.len() - 1); } } } (Some(parent), None) if is_inherent_impl_item => { // We have a parent, but we don't know where they're // defined yet. Wait for later to index this item. - self.orphan_impl_items.push((parent, item.clone())); + self.cache.orphan_impl_items.push((parent, item.clone())); } _ => {} } @@ -339,7 +351,7 @@ impl DocFolder for Cache { // Keep track of the fully qualified path for this item. let pushed = match item.name { Some(n) if !n.is_empty() => { - self.stack.push(n.to_string()); + self.cache.stack.push(n.to_string()); true } _ => false, @@ -361,7 +373,7 @@ impl DocFolder for Cache { | clean::MacroItem(..) | clean::ProcMacroItem(..) | clean::VariantItem(..) - if !self.stripped_mod => + if !self.cache.stripped_mod => { // Re-exported items mean that the same id can show up twice // in the rustdoc ast that we're looking at. We know, @@ -369,21 +381,21 @@ impl DocFolder for Cache { // `public_items` map, so we can skip inserting into the // paths map if there was already an entry present and we're // not a public item. - if !self.paths.contains_key(&item.def_id) - || self.access_levels.is_public(item.def_id) + if !self.cache.paths.contains_key(&item.def_id) + || self.cache.access_levels.is_public(item.def_id) { - self.paths.insert(item.def_id, (self.stack.clone(), item.type_())); + self.cache.paths.insert(item.def_id, (self.cache.stack.clone(), item.type_())); } } clean::PrimitiveItem(..) => { - self.paths.insert(item.def_id, (self.stack.clone(), item.type_())); + self.cache.paths.insert(item.def_id, (self.cache.stack.clone(), item.type_())); } _ => {} } // Maintain the parent stack - let orig_parent_is_trait_impl = self.parent_is_trait_impl; + let orig_parent_is_trait_impl = self.cache.parent_is_trait_impl; let parent_pushed = match *item.kind { clean::TraitItem(..) | clean::EnumItem(..) @@ -391,24 +403,24 @@ impl DocFolder for Cache { | clean::StructItem(..) | clean::UnionItem(..) | clean::VariantItem(..) => { - self.parent_stack.push(item.def_id); - self.parent_is_trait_impl = false; + self.cache.parent_stack.push(item.def_id); + self.cache.parent_is_trait_impl = false; true } clean::ImplItem(ref i) => { - self.parent_is_trait_impl = i.trait_.is_some(); + self.cache.parent_is_trait_impl = i.trait_.is_some(); match i.for_ { clean::ResolvedPath { did, .. } => { - self.parent_stack.push(did); + self.cache.parent_stack.push(did); true } ref t => { let prim_did = t .primitive_type() - .and_then(|t| self.primitive_locations.get(&t).cloned()); + .and_then(|t| self.cache.primitive_locations.get(&t).cloned()); match prim_did { Some(did) => { - self.parent_stack.push(did); + self.cache.parent_stack.push(did); true } None => false, @@ -433,8 +445,9 @@ impl DocFolder for Cache { dids.insert(did); } ref t => { - let did = - t.primitive_type().and_then(|t| self.primitive_locations.get(&t).cloned()); + let did = t + .primitive_type() + .and_then(|t| self.cache.primitive_locations.get(&t).cloned()); if let Some(did) = did { dids.insert(did); @@ -450,13 +463,13 @@ impl DocFolder for Cache { } } let impl_item = Impl { impl_item: item }; - if impl_item.trait_did().map_or(true, |d| self.traits.contains_key(&d)) { + if impl_item.trait_did().map_or(true, |d| self.cache.traits.contains_key(&d)) { for did in dids { - self.impls.entry(did).or_insert(vec![]).push(impl_item.clone()); + self.cache.impls.entry(did).or_insert(vec![]).push(impl_item.clone()); } } else { let trait_did = impl_item.trait_did().expect("no trait did"); - self.orphan_trait_impls.push((trait_did, dids, impl_item)); + self.cache.orphan_trait_impls.push((trait_did, dids, impl_item)); } None } else { @@ -464,13 +477,13 @@ impl DocFolder for Cache { }; if pushed { - self.stack.pop().expect("stack already empty"); + self.cache.stack.pop().expect("stack already empty"); } if parent_pushed { - self.parent_stack.pop().expect("parent stack already empty"); + self.cache.parent_stack.pop().expect("parent stack already empty"); } - self.stripped_mod = orig_stripped_mod; - self.parent_is_trait_impl = orig_parent_is_trait_impl; + self.cache.stripped_mod = orig_stripped_mod; + self.cache.parent_is_trait_impl = orig_parent_is_trait_impl; ret } } diff --git a/src/librustdoc/formats/renderer.rs b/src/librustdoc/formats/renderer.rs index 6ecc4695dc8..6437ba45511 100644 --- a/src/librustdoc/formats/renderer.rs +++ b/src/librustdoc/formats/renderer.rs @@ -61,6 +61,7 @@ crate fn run_format<'tcx, T: FormatRenderer<'tcx>>( &options.extern_html_root_urls, &options.output, krate, + tcx, ) }); let prof = &tcx.sess.prof; diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 74b61f1555c..bea0e75832c 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -102,14 +102,6 @@ impl Buffer { self.into_inner() } - crate fn from_display<T: std::fmt::Display>(&mut self, t: T) { - if self.for_html { - write!(self, "{}", t); - } else { - write!(self, "{:#}", t); - } - } - crate fn is_for_html(&self) -> bool { self.for_html } @@ -900,16 +892,7 @@ impl clean::Type { } impl clean::Impl { - crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { - self.print_inner(true, false, cache) - } - - fn print_inner<'a>( - &'a self, - link_trait: bool, - use_absolute: bool, - cache: &'a Cache, - ) -> impl fmt::Display + 'a { + crate fn print<'a>(&'a self, cache: &'a Cache, use_absolute: bool) -> impl fmt::Display + 'a { display_fn(move |f| { if f.alternate() { write!(f, "impl{:#} ", self.generics.print(cache))?; @@ -921,21 +904,7 @@ impl clean::Impl { if self.negative_polarity { write!(f, "!")?; } - - if link_trait { - fmt::Display::fmt(&ty.print(cache), f)?; - } else { - match ty { - clean::ResolvedPath { - param_names: None, path, is_generic: false, .. - } => { - let last = path.segments.last().unwrap(); - fmt::Display::fmt(&last.name, f)?; - fmt::Display::fmt(&last.args.print(cache), f)?; - } - _ => unreachable!(), - } - } + fmt::Display::fmt(&ty.print(cache), f)?; write!(f, " for ")?; } @@ -952,16 +921,6 @@ impl clean::Impl { } } -// The difference from above is that trait is not hyperlinked. -crate fn fmt_impl_for_trait_page( - i: &clean::Impl, - f: &mut Buffer, - use_absolute: bool, - cache: &Cache, -) { - f.from_display(i.print_inner(false, use_absolute, cache)) -} - impl clean::Arguments { crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| { @@ -1331,16 +1290,16 @@ impl clean::GenericArg { } crate fn display_fn(f: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result) -> impl fmt::Display { - WithFormatter(Cell::new(Some(f))) -} - -struct WithFormatter<F>(Cell<Option<F>>); - -impl<F> fmt::Display for WithFormatter<F> -where - F: FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result, -{ - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - (self.0.take()).unwrap()(f) + struct WithFormatter<F>(Cell<Option<F>>); + + impl<F> fmt::Display for WithFormatter<F> + where + F: FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result, + { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + (self.0.take()).unwrap()(f) + } } + + WithFormatter(Cell::new(Some(f))) } diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index bdb92844f07..a81fd55f6f1 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -48,7 +48,10 @@ mod tests; /// Options for rendering Markdown in the main body of documentation. pub(crate) fn opts() -> Options { - Options::ENABLE_TABLES | Options::ENABLE_FOOTNOTES | Options::ENABLE_STRIKETHROUGH + Options::ENABLE_TABLES + | Options::ENABLE_FOOTNOTES + | Options::ENABLE_STRIKETHROUGH + | Options::ENABLE_TASKLISTS } /// A subset of [`opts()`] used for rendering summaries. diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs index 4dd7110f331..a21cf5266fe 100644 --- a/src/librustdoc/html/render/cache.rs +++ b/src/librustdoc/html/render/cache.rs @@ -1,11 +1,14 @@ use std::collections::BTreeMap; use std::path::Path; -use rustc_data_structures::fx::FxHashMap; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use rustc_middle::ty::TyCtxt; use rustc_span::symbol::{sym, Symbol}; use serde::Serialize; -use crate::clean::types::GetDefId; +use crate::clean::types::{ + FnDecl, FnRetTy, GenericBound, Generics, GetDefId, Type, TypeKind, WherePredicate, +}; use crate::clean::{self, AttributesExt}; use crate::formats::cache::Cache; use crate::formats::item_type::ItemType; @@ -62,7 +65,7 @@ crate fn extern_location( } /// Builds the search index from the collected metadata -crate fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String { +crate fn build_index<'tcx>(krate: &clean::Crate, cache: &mut Cache, tcx: TyCtxt<'tcx>) -> String { let mut defid_to_pathid = FxHashMap::default(); let mut crate_items = Vec::with_capacity(cache.search_index.len()); let mut crate_paths = vec![]; @@ -78,7 +81,7 @@ crate fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String { desc: item.doc_value().map_or_else(String::new, |s| short_markdown_summary(&s)), parent: Some(did), parent_idx: None, - search_type: get_index_search_type(&item, Some(cache)), + search_type: get_index_search_type(&item, cache, tcx), }); for alias in item.attrs.get_doc_aliases() { cache @@ -164,14 +167,15 @@ crate fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String { ) } -crate fn get_index_search_type( +crate fn get_index_search_type<'tcx>( item: &clean::Item, - cache: Option<&Cache>, + cache: &Cache, + tcx: TyCtxt<'tcx>, ) -> Option<IndexItemFunctionType> { let (all_types, ret_types) = match *item.kind { - clean::FunctionItem(ref f) => (&f.all_types, &f.ret_types), - clean::MethodItem(ref m, _) => (&m.all_types, &m.ret_types), - clean::TyMethodItem(ref m) => (&m.all_types, &m.ret_types), + clean::FunctionItem(ref f) => get_all_types(&f.generics, &f.decl, tcx), + clean::MethodItem(ref m, _) => get_all_types(&m.generics, &m.decl, tcx), + clean::TyMethodItem(ref m) => get_all_types(&m.generics, &m.decl, tcx), _ => return None, }; @@ -190,9 +194,9 @@ crate fn get_index_search_type( Some(IndexItemFunctionType { inputs, output }) } -fn get_index_type(clean_type: &clean::Type, cache: &Option<&Cache>) -> RenderType { +fn get_index_type(clean_type: &clean::Type, cache: &Cache) -> RenderType { RenderType { - ty: cache.map_or_else(|| clean_type.def_id(), |cache| clean_type.def_id_full(cache)), + ty: clean_type.def_id_full(cache), idx: None, name: get_index_type_name(clean_type, true).map(|s| s.as_str().to_ascii_lowercase()), generics: get_generics(clean_type, cache), @@ -227,14 +231,14 @@ fn get_index_type_name(clean_type: &clean::Type, accept_generic: bool) -> Option } } -fn get_generics(clean_type: &clean::Type, cache: &Option<&Cache>) -> Option<Vec<Generic>> { +fn get_generics(clean_type: &clean::Type, cache: &Cache) -> Option<Vec<Generic>> { clean_type.generics().and_then(|types| { let r = types .iter() .filter_map(|t| { get_index_type_name(t, false).map(|name| Generic { name: name.as_str().to_ascii_lowercase(), - defid: cache.map_or_else(|| t.def_id(), |cache| t.def_id_full(cache)), + defid: t.def_id_full(cache), idx: None, }) }) @@ -242,3 +246,124 @@ fn get_generics(clean_type: &clean::Type, cache: &Option<&Cache>) -> Option<Vec< if r.is_empty() { None } else { Some(r) } }) } + +/// The point of this function is to replace bounds with types. +/// +/// i.e. `[T, U]` when you have the following bounds: `T: Display, U: Option<T>` will return +/// `[Display, Option]` (we just returns the list of the types, we don't care about the +/// wrapped types in here). +crate fn get_real_types<'tcx>( + generics: &Generics, + arg: &Type, + tcx: TyCtxt<'tcx>, + recurse: i32, + res: &mut FxHashSet<(Type, TypeKind)>, +) -> usize { + fn insert(res: &mut FxHashSet<(Type, TypeKind)>, tcx: TyCtxt<'_>, ty: Type) -> usize { + if let Some(kind) = ty.def_id().map(|did| tcx.def_kind(did).into()) { + res.insert((ty, kind)); + 1 + } else if ty.is_primitive() { + // This is a primitive, let's store it as such. + res.insert((ty, TypeKind::Primitive)); + 1 + } else { + 0 + } + } + + if recurse >= 10 { + // FIXME: remove this whole recurse thing when the recursion bug is fixed + return 0; + } + let mut nb_added = 0; + + if let &Type::Generic(arg_s) = arg { + if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g { + WherePredicate::BoundPredicate { ty, .. } => ty.def_id() == arg.def_id(), + _ => false, + }) { + let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]); + for bound in bounds.iter() { + if let GenericBound::TraitBound(poly_trait, _) = bound { + for x in poly_trait.generic_params.iter() { + if !x.is_type() { + continue; + } + if let Some(ty) = x.get_type() { + let adds = get_real_types(generics, &ty, tcx, recurse + 1, res); + nb_added += adds; + if adds == 0 && !ty.is_full_generic() { + nb_added += insert(res, tcx, ty); + } + } + } + } + } + } + if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) { + for bound in bound.get_bounds().unwrap_or(&[]) { + if let Some(ty) = bound.get_trait_type() { + let adds = get_real_types(generics, &ty, tcx, recurse + 1, res); + nb_added += adds; + if adds == 0 && !ty.is_full_generic() { + nb_added += insert(res, tcx, ty); + } + } + } + } + } else { + nb_added += insert(res, tcx, arg.clone()); + if let Some(gens) = arg.generics() { + for gen in gens.iter() { + if gen.is_full_generic() { + nb_added += get_real_types(generics, gen, tcx, recurse + 1, res); + } else { + nb_added += insert(res, tcx, (*gen).clone()); + } + } + } + } + nb_added +} + +/// Return the full list of types when bounds have been resolved. +/// +/// i.e. `fn foo<A: Display, B: Option<A>>(x: u32, y: B)` will return +/// `[u32, Display, Option]`. +crate fn get_all_types<'tcx>( + generics: &Generics, + decl: &FnDecl, + tcx: TyCtxt<'tcx>, +) -> (Vec<(Type, TypeKind)>, Vec<(Type, TypeKind)>) { + let mut all_types = FxHashSet::default(); + for arg in decl.inputs.values.iter() { + if arg.type_.is_self_type() { + continue; + } + let mut args = FxHashSet::default(); + get_real_types(generics, &arg.type_, tcx, 0, &mut args); + if !args.is_empty() { + all_types.extend(args); + } else { + if let Some(kind) = arg.type_.def_id().map(|did| tcx.def_kind(did).into()) { + all_types.insert((arg.type_.clone(), kind)); + } + } + } + + let ret_types = match decl.output { + FnRetTy::Return(ref return_type) => { + let mut ret = FxHashSet::default(); + get_real_types(generics, &return_type, tcx, 0, &mut ret); + if ret.is_empty() { + if let Some(kind) = return_type.def_id().map(|did| tcx.def_kind(did).into()) { + ret.insert((return_type.clone(), kind)); + } + } + ret.into_iter().collect() + } + _ => Vec::new(), + }; + (all_types.into_iter().collect(), ret_types) +} diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index 6909ab870db..914ad35e7a4 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -73,7 +73,6 @@ use crate::formats::cache::Cache; use crate::formats::item_type::ItemType; use crate::formats::{AssocItemRender, FormatRenderer, Impl, RenderMode}; use crate::html::escape::Escape; -use crate::html::format::fmt_impl_for_trait_page; use crate::html::format::Function; use crate::html::format::{href, print_default_space, print_generic_bounds, WhereClause}; use crate::html::format::{print_abi_with_space, Buffer, PrintWithSpace}; @@ -499,7 +498,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { krate = sources::render(&dst, &mut scx, krate)?; // Build our search index - let index = build_index(&krate, &mut cache); + let index = build_index(&krate, &mut cache, tcx); let mut cx = Context { current: Vec::new(), @@ -1138,7 +1137,7 @@ themePicker.onblur = handleThemeButtonsBlur; None } else { Some(Implementor { - text: imp.inner_impl().print(cx.cache()).to_string(), + text: imp.inner_impl().print(cx.cache(), false).to_string(), synthetic: imp.inner_impl().synthetic, types: collect_paths_for_type(imp.inner_impl().for_.clone(), cx.cache()), }) @@ -2550,8 +2549,8 @@ fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool, cache: &Cache) -> } fn compare_impl<'a, 'b>(lhs: &'a &&Impl, rhs: &'b &&Impl, cache: &Cache) -> Ordering { - let lhs = format!("{}", lhs.inner_impl().print(cache)); - let rhs = format!("{}", rhs.inner_impl().print(cache)); + let lhs = format!("{}", lhs.inner_impl().print(cache, false)); + let rhs = format!("{}", rhs.inner_impl().print(cache, false)); // lhs and rhs are formatted as HTML, which may be unnecessary compare_names(&lhs, &rhs) @@ -3698,7 +3697,7 @@ fn spotlight_decl(decl: &clean::FnDecl, cache: &Cache) -> String { write!( &mut out, "<span class=\"where fmt-newline\">{}</span>", - impl_.print(cache) + impl_.print(cache, false) ); let t_did = impl_.trait_.def_id_full(cache).unwrap(); for it in &impl_.items { @@ -3771,7 +3770,7 @@ fn render_impl( }; if let Some(use_absolute) = use_absolute { write!(w, "<h3 id=\"{}\" class=\"impl\"{}><code class=\"in-band\">", id, aliases); - fmt_impl_for_trait_page(&i.inner_impl(), w, use_absolute, cx.cache()); + write!(w, "{}", i.inner_impl().print(cx.cache(), use_absolute)); if show_def_docs { for it in &i.inner_impl().items { if let clean::TypedefItem(ref tydef, _) = *it.kind { @@ -3796,7 +3795,7 @@ fn render_impl( "<h3 id=\"{}\" class=\"impl\"{}><code class=\"in-band\">{}</code>", id, aliases, - i.inner_impl().print(cx.cache()) + i.inner_impl().print(cx.cache(), false) ); } write!(w, "<a href=\"#{}\" class=\"anchor\"></a>", id); diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs index b2e5c8834b8..e021faa5041 100644 --- a/src/librustdoc/json/conversions.rs +++ b/src/librustdoc/json/conversions.rs @@ -154,7 +154,7 @@ impl From<clean::ItemKind> for ItemEnum { } ImportItem(i) => ItemEnum::ImportItem(i.into()), StructItem(s) => ItemEnum::StructItem(s.into()), - UnionItem(u) => ItemEnum::StructItem(u.into()), + UnionItem(u) => ItemEnum::UnionItem(u.into()), StructFieldItem(f) => ItemEnum::StructFieldItem(f.into()), EnumItem(e) => ItemEnum::EnumItem(e.into()), VariantItem(v) => ItemEnum::VariantItem(v.into()), @@ -162,8 +162,8 @@ impl From<clean::ItemKind> for ItemEnum { ForeignFunctionItem(f) => ItemEnum::FunctionItem(f.into()), TraitItem(t) => ItemEnum::TraitItem(t.into()), TraitAliasItem(t) => ItemEnum::TraitAliasItem(t.into()), - MethodItem(m, _) => ItemEnum::MethodItem(m.into()), - TyMethodItem(m) => ItemEnum::MethodItem(m.into()), + MethodItem(m, _) => ItemEnum::MethodItem(from_function_method(m, true)), + TyMethodItem(m) => ItemEnum::MethodItem(from_function_method(m, false)), ImplItem(i) => ItemEnum::ImplItem(i.into()), StaticItem(s) => ItemEnum::StaticItem(s.into()), ForeignStaticItem(s) => ItemEnum::StaticItem(s.into()), @@ -205,11 +205,10 @@ impl From<clean::Struct> for Struct { } } -impl From<clean::Union> for Struct { +impl From<clean::Union> for Union { fn from(struct_: clean::Union) -> Self { let clean::Union { generics, fields, fields_stripped } = struct_; - Struct { - struct_type: StructType::Union, + Union { generics: generics.into(), fields_stripped, fields: ids(fields), @@ -239,7 +238,7 @@ fn stringify_header(header: &rustc_hir::FnHeader) -> String { impl From<clean::Function> for Function { fn from(function: clean::Function) -> Self { - let clean::Function { decl, generics, header, all_types: _, ret_types: _ } = function; + let clean::Function { decl, generics, header } = function; Function { decl: decl.into(), generics: generics.into(), @@ -435,15 +434,14 @@ impl From<clean::Impl> for Impl { } } -impl From<clean::Function> for Method { - fn from(function: clean::Function) -> Self { - let clean::Function { header, decl, generics, all_types: _, ret_types: _ } = function; - Method { - decl: decl.into(), - generics: generics.into(), - header: stringify_header(&header), - has_body: true, - } +crate fn from_function_method(function: clean::Function, has_body: bool) -> Method { + let clean::Function { header, decl, generics } = function; + Method { + decl: decl.into(), + generics: generics.into(), + header: stringify_header(&header), + abi: header.abi.to_string(), + has_body, } } diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs index a7c875fb748..876b1b56dee 100644 --- a/src/librustdoc/json/mod.rs +++ b/src/librustdoc/json/mod.rs @@ -243,7 +243,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> { ) }) .collect(), - format_version: 2, + format_version: 3, }; let mut p = self.out_path.clone(); p.push(output.index.get(&output.root).unwrap().name.clone().unwrap()); diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 87a6098e492..18bc275572f 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -9,7 +9,6 @@ #![feature(in_band_lifetimes)] #![feature(nll)] #![feature(or_patterns)] -#![feature(peekable_next_if)] #![feature(test)] #![feature(crate_visibility_modifier)] #![feature(never_type)] diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs index 002d8938f69..532a0cf9329 100644 --- a/src/librustdoc/passes/collect_intra_doc_links.rs +++ b/src/librustdoc/passes/collect_intra_doc_links.rs @@ -44,7 +44,7 @@ use super::span_of_attrs; crate const COLLECT_INTRA_DOC_LINKS: Pass = Pass { name: "collect-intra-doc-links", run: collect_intra_doc_links, - description: "reads a crate's documentation to resolve intra-doc-links", + description: "resolves intra-doc links", }; crate fn collect_intra_doc_links(krate: Crate, cx: &DocContext<'_>) -> Crate { @@ -981,7 +981,7 @@ impl LinkCollector<'_, '_> { let link_text = disambiguator.map(|d| d.display_for(path_str)).unwrap_or_else(|| path_str.to_owned()); - // In order to correctly resolve intra-doc-links we need to + // In order to correctly resolve intra-doc links we need to // pick a base AST node to work from. If the documentation for // this module came from an inner comment (//!) then we anchor // our name resolution *inside* the module. If, on the other diff --git a/src/librustdoc/passes/doc_test_lints.rs b/src/librustdoc/passes/doc_test_lints.rs index a513c2abc87..11f572560d6 100644 --- a/src/librustdoc/passes/doc_test_lints.rs +++ b/src/librustdoc/passes/doc_test_lints.rs @@ -1,7 +1,7 @@ //! This pass is overloaded and runs two different lints. //! -//! - MISSING_DOC_CODE_EXAMPLES: this lint is **UNSTABLE** and looks for public items missing doc-tests -//! - PRIVATE_DOC_TESTS: this lint is **STABLE** and looks for private items with doc-tests. +//! - MISSING_DOC_CODE_EXAMPLES: this lint is **UNSTABLE** and looks for public items missing doctests +//! - PRIVATE_DOC_TESTS: this lint is **STABLE** and looks for private items with doctests. use super::{span_of_attrs, Pass}; use crate::clean; diff --git a/src/librustdoc/passes/non_autolinks.rs b/src/librustdoc/passes/non_autolinks.rs index 1f411b997f8..efb5df08caf 100644 --- a/src/librustdoc/passes/non_autolinks.rs +++ b/src/librustdoc/passes/non_autolinks.rs @@ -12,7 +12,7 @@ use rustc_session::lint; crate const CHECK_NON_AUTOLINKS: Pass = Pass { name: "check-non-autolinks", run: check_non_autolinks, - description: "detects URLS that could be written using angle brackets", + description: "detects URLs that could be linkified", }; const URL_REGEX: &str = concat!( diff --git a/src/librustdoc/passes/strip_hidden.rs b/src/librustdoc/passes/strip_hidden.rs index a276b7a6337..79f8562c472 100644 --- a/src/librustdoc/passes/strip_hidden.rs +++ b/src/librustdoc/passes/strip_hidden.rs @@ -11,7 +11,7 @@ use crate::passes::{ImplStripper, Pass}; crate const STRIP_HIDDEN: Pass = Pass { name: "strip-hidden", run: strip_hidden, - description: "strips all doc(hidden) items from the output", + description: "strips all `#[doc(hidden)]` items from the output", }; /// Strip items marked `#[doc(hidden)]` diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs index 3fb2a32d5a0..297fc95006b 100644 --- a/src/rustdoc-json-types/lib.rs +++ b/src/rustdoc-json-types/lib.rs @@ -96,8 +96,8 @@ pub struct Deprecation { pub note: Option<String>, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum Visibility { Public, /// For the most part items are private by default. The exceptions are associated items of @@ -112,8 +112,8 @@ pub enum Visibility { }, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum GenericArgs { /// <'a, 32, B: Copy, C = u32> AngleBracketed { args: Vec<GenericArg>, bindings: Vec<TypeBinding> }, @@ -121,8 +121,8 @@ pub enum GenericArgs { Parenthesized { inputs: Vec<Type>, output: Option<Type> }, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum GenericArg { Lifetime(String), Type(Type), @@ -144,8 +144,8 @@ pub struct TypeBinding { pub binding: TypeBindingKind, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum TypeBindingKind { Equality(Type), Constraint(Vec<GenericBound>), @@ -154,8 +154,8 @@ pub enum TypeBindingKind { #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] pub struct Id(pub String); -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum ItemKind { Module, ExternCrate, @@ -184,8 +184,8 @@ pub enum ItemKind { Keyword, } -#[serde(untagged)] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(untagged)] pub enum ItemEnum { ModuleItem(Module), ExternCrateItem { @@ -194,6 +194,7 @@ pub enum ItemEnum { }, ImportItem(Import), + UnionItem(Union), StructItem(Struct), StructFieldItem(Type), EnumItem(Enum), @@ -239,6 +240,14 @@ pub struct Module { } #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct Union { + pub generics: Generics, + pub fields_stripped: bool, + pub fields: Vec<Id>, + pub impls: Vec<Id>, +} + +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] pub struct Struct { pub struct_type: StructType, pub generics: Generics, @@ -255,22 +264,21 @@ pub struct Enum { pub impls: Vec<Id>, } +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] #[serde(rename_all = "snake_case")] #[serde(tag = "variant_kind", content = "variant_inner")] -#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] pub enum Variant { Plain, Tuple(Vec<Type>), Struct(Vec<Id>), } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum StructType { Plain, Tuple, Unit, - Union, } #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] @@ -286,6 +294,7 @@ pub struct Method { pub decl: FnDecl, pub generics: Generics, pub header: String, + pub abi: String, pub has_body: bool, } @@ -301,24 +310,24 @@ pub struct GenericParamDef { pub kind: GenericParamDefKind, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum GenericParamDefKind { Lifetime, Type { bounds: Vec<GenericBound>, default: Option<Type> }, Const(Type), } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum WherePredicate { BoundPredicate { ty: Type, bounds: Vec<GenericBound> }, RegionPredicate { lifetime: String, bounds: Vec<GenericBound> }, EqPredicate { lhs: Type, rhs: Type }, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum GenericBound { TraitBound { #[serde(rename = "trait")] @@ -330,17 +339,17 @@ pub enum GenericBound { Outlives(String), } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum TraitBoundModifier { None, Maybe, MaybeConst, } +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] #[serde(rename_all = "snake_case")] #[serde(tag = "kind", content = "inner")] -#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] pub enum Type { /// Structs, enums, and traits ResolvedPath { @@ -439,8 +448,8 @@ pub struct Impl { pub blanket_impl: Option<Type>, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub struct Import { /// The full path being imported. pub span: String, @@ -459,8 +468,8 @@ pub struct ProcMacro { pub helpers: Vec<String>, } -#[serde(rename_all = "snake_case")] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] pub enum MacroKind { /// A bang macro `foo!()`. Bang, diff --git a/src/test/codegen/asm-sanitize-llvm.rs b/src/test/codegen/asm-sanitize-llvm.rs new file mode 100644 index 00000000000..fe09caa6973 --- /dev/null +++ b/src/test/codegen/asm-sanitize-llvm.rs @@ -0,0 +1,32 @@ +// FIXME(nagisa): remove the flags here once all targets support `asm!`. +// compile-flags: --target x86_64-unknown-linux-gnu + +// Verify we sanitize the special tokens for the LLVM inline-assembly, ensuring people won't +// inadvertently rely on the LLVM-specific syntax and features. +#![no_core] +#![feature(no_core, lang_items, rustc_attrs)] +#![crate_type = "rlib"] + +#[rustc_builtin_macro] +macro_rules! asm { + () => {}; +} + +#[lang = "sized"] +trait Sized {} +#[lang = "copy"] +trait Copy {} + +pub unsafe fn we_escape_dollar_signs() { + // CHECK: call void asm sideeffect alignstack inteldialect "banana$$:" + asm!( + r"banana$:", + ) +} + +pub unsafe fn we_escape_escapes_too() { + // CHECK: call void asm sideeffect alignstack inteldialect "banana\{{(\\|5C)}}36:" + asm!( + r"banana\36:", + ) +} diff --git a/src/test/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir b/src/test/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir index 0c7b64cb97f..7e0ca3dea4b 100644 --- a/src/test/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir +++ b/src/test/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir @@ -41,36 +41,44 @@ fn main() -> () { StorageLive(_5); // scope 3 at $DIR/basic_assignment.rs:19:9: 19:15 StorageLive(_6); // scope 4 at $DIR/basic_assignment.rs:23:14: 23:20 _6 = move _4; // scope 4 at $DIR/basic_assignment.rs:23:14: 23:20 - replace(_5 <- move _6) -> [return: bb1, unwind: bb4]; // scope 4 at $DIR/basic_assignment.rs:23:5: 23:11 + replace(_5 <- move _6) -> [return: bb1, unwind: bb5]; // scope 4 at $DIR/basic_assignment.rs:23:5: 23:11 } bb1: { + drop(_6) -> [return: bb2, unwind: bb6]; // scope 4 at $DIR/basic_assignment.rs:23:19: 23:20 + } + + bb2: { StorageDead(_6); // scope 4 at $DIR/basic_assignment.rs:23:19: 23:20 _0 = const (); // scope 0 at $DIR/basic_assignment.rs:10:11: 24:2 - drop(_5) -> [return: bb2, unwind: bb5]; // scope 3 at $DIR/basic_assignment.rs:24:1: 24:2 + drop(_5) -> [return: bb3, unwind: bb7]; // scope 3 at $DIR/basic_assignment.rs:24:1: 24:2 } - bb2: { + bb3: { StorageDead(_5); // scope 3 at $DIR/basic_assignment.rs:24:1: 24:2 - drop(_4) -> [return: bb3, unwind: bb6]; // scope 2 at $DIR/basic_assignment.rs:24:1: 24:2 + drop(_4) -> [return: bb4, unwind: bb8]; // scope 2 at $DIR/basic_assignment.rs:24:1: 24:2 } - bb3: { + bb4: { StorageDead(_4); // scope 2 at $DIR/basic_assignment.rs:24:1: 24:2 StorageDead(_2); // scope 1 at $DIR/basic_assignment.rs:24:1: 24:2 StorageDead(_1); // scope 0 at $DIR/basic_assignment.rs:24:1: 24:2 return; // scope 0 at $DIR/basic_assignment.rs:24:2: 24:2 } - bb4 (cleanup): { - drop(_5) -> bb5; // scope 3 at $DIR/basic_assignment.rs:24:1: 24:2 - } - bb5 (cleanup): { - drop(_4) -> bb6; // scope 2 at $DIR/basic_assignment.rs:24:1: 24:2 + drop(_6) -> bb6; // scope 4 at $DIR/basic_assignment.rs:23:19: 23:20 } bb6 (cleanup): { + drop(_5) -> bb7; // scope 3 at $DIR/basic_assignment.rs:24:1: 24:2 + } + + bb7 (cleanup): { + drop(_4) -> bb8; // scope 2 at $DIR/basic_assignment.rs:24:1: 24:2 + } + + bb8 (cleanup): { resume; // scope 0 at $DIR/basic_assignment.rs:10:1: 24:2 } } diff --git a/src/test/mir-opt/box_expr.main.ElaborateDrops.before.mir b/src/test/mir-opt/box_expr.main.ElaborateDrops.before.mir index 20ea7b026bc..cfbd3a58637 100644 --- a/src/test/mir-opt/box_expr.main.ElaborateDrops.before.mir +++ b/src/test/mir-opt/box_expr.main.ElaborateDrops.before.mir @@ -14,7 +14,7 @@ fn main() -> () { StorageLive(_1); // scope 0 at $DIR/box_expr.rs:7:9: 7:10 StorageLive(_2); // scope 0 at $DIR/box_expr.rs:7:13: 7:25 _2 = Box(S); // scope 0 at $DIR/box_expr.rs:7:13: 7:25 - (*_2) = S::new() -> [return: bb1, unwind: bb5]; // scope 0 at $DIR/box_expr.rs:7:17: 7:25 + (*_2) = S::new() -> [return: bb1, unwind: bb7]; // scope 0 at $DIR/box_expr.rs:7:17: 7:25 // mir::Constant // + span: $DIR/box_expr.rs:7:17: 7:23 // + literal: Const { ty: fn() -> S {S::new}, val: Value(Scalar(<ZST>)) } @@ -22,37 +22,45 @@ fn main() -> () { bb1: { _1 = move _2; // scope 0 at $DIR/box_expr.rs:7:13: 7:25 + drop(_2) -> bb2; // scope 0 at $DIR/box_expr.rs:7:24: 7:25 + } + + bb2: { StorageDead(_2); // scope 0 at $DIR/box_expr.rs:7:24: 7:25 StorageLive(_3); // scope 1 at $DIR/box_expr.rs:8:5: 8:12 StorageLive(_4); // scope 1 at $DIR/box_expr.rs:8:10: 8:11 _4 = move _1; // scope 1 at $DIR/box_expr.rs:8:10: 8:11 - _3 = std::mem::drop::<Box<S>>(move _4) -> [return: bb2, unwind: bb4]; // scope 1 at $DIR/box_expr.rs:8:5: 8:12 + _3 = std::mem::drop::<Box<S>>(move _4) -> [return: bb3, unwind: bb5]; // scope 1 at $DIR/box_expr.rs:8:5: 8:12 // mir::Constant // + span: $DIR/box_expr.rs:8:5: 8:9 // + literal: Const { ty: fn(std::boxed::Box<S>) {std::mem::drop::<std::boxed::Box<S>>}, val: Value(Scalar(<ZST>)) } } - bb2: { + bb3: { StorageDead(_4); // scope 1 at $DIR/box_expr.rs:8:11: 8:12 StorageDead(_3); // scope 1 at $DIR/box_expr.rs:8:12: 8:13 _0 = const (); // scope 0 at $DIR/box_expr.rs:6:11: 9:2 - drop(_1) -> bb3; // scope 0 at $DIR/box_expr.rs:9:1: 9:2 + drop(_1) -> bb4; // scope 0 at $DIR/box_expr.rs:9:1: 9:2 } - bb3: { + bb4: { StorageDead(_1); // scope 0 at $DIR/box_expr.rs:9:1: 9:2 return; // scope 0 at $DIR/box_expr.rs:9:2: 9:2 } - bb4 (cleanup): { - drop(_1) -> bb6; // scope 0 at $DIR/box_expr.rs:9:1: 9:2 - } - bb5 (cleanup): { - drop(_2) -> bb6; // scope 0 at $DIR/box_expr.rs:7:24: 7:25 + drop(_4) -> bb6; // scope 1 at $DIR/box_expr.rs:8:11: 8:12 } bb6 (cleanup): { + drop(_1) -> bb8; // scope 0 at $DIR/box_expr.rs:9:1: 9:2 + } + + bb7 (cleanup): { + drop(_2) -> bb8; // scope 0 at $DIR/box_expr.rs:7:24: 7:25 + } + + bb8 (cleanup): { resume; // scope 0 at $DIR/box_expr.rs:6:1: 9:2 } } diff --git a/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.before-SimplifyBranches-final.after.diff b/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.before-SimplifyBranches-final.after.diff index f51a08ed730..1b292cdd796 100644 --- a/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.before-SimplifyBranches-final.after.diff +++ b/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.before-SimplifyBranches-final.after.diff @@ -1,7 +1,7 @@ - // MIR for `try_sum` before EarlyOtherwiseBranch + // MIR for `try_sum` after SimplifyBranches-final - fn try_sum(_1: &ViewportPercentageLength, _2: &ViewportPercentageLength) -> std::result::Result<ViewportPercentageLength, ()> { + fn try_sum(_1: &ViewportPercentageLength, _2: &ViewportPercentageLength) -> Result<ViewportPercentageLength, ()> { debug x => _1; // in scope 0 at $DIR/early_otherwise_branch_68867.rs:18:5: 18:6 debug other => _2; // in scope 0 at $DIR/early_otherwise_branch_68867.rs:19:5: 19:10 let mut _0: std::result::Result<ViewportPercentageLength, ()>; // return place in scope 0 at $DIR/early_otherwise_branch_68867.rs:20:6: 20:42 diff --git a/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff b/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff index 05ef6721e65..d20ee784591 100644 --- a/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff +++ b/src/test/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff @@ -1,7 +1,7 @@ - // MIR for `try_sum` before EarlyOtherwiseBranch + // MIR for `try_sum` after EarlyOtherwiseBranch - fn try_sum(_1: &ViewportPercentageLength, _2: &ViewportPercentageLength) -> std::result::Result<ViewportPercentageLength, ()> { + fn try_sum(_1: &ViewportPercentageLength, _2: &ViewportPercentageLength) -> Result<ViewportPercentageLength, ()> { debug x => _1; // in scope 0 at $DIR/early_otherwise_branch_68867.rs:18:5: 18:6 debug other => _2; // in scope 0 at $DIR/early_otherwise_branch_68867.rs:19:5: 19:10 let mut _0: std::result::Result<ViewportPercentageLength, ()>; // return place in scope 0 at $DIR/early_otherwise_branch_68867.rs:20:6: 20:42 diff --git a/src/test/mir-opt/funky_arms.float_to_exponential_common.ConstProp.diff b/src/test/mir-opt/funky_arms.float_to_exponential_common.ConstProp.diff index bb79cd80e51..caa02abf019 100644 --- a/src/test/mir-opt/funky_arms.float_to_exponential_common.ConstProp.diff +++ b/src/test/mir-opt/funky_arms.float_to_exponential_common.ConstProp.diff @@ -1,7 +1,7 @@ - // MIR for `float_to_exponential_common` before ConstProp + // MIR for `float_to_exponential_common` after ConstProp - fn float_to_exponential_common(_1: &mut Formatter, _2: &T, _3: bool) -> std::result::Result<(), std::fmt::Error> { + fn float_to_exponential_common(_1: &mut Formatter, _2: &T, _3: bool) -> Result<(), std::fmt::Error> { debug fmt => _1; // in scope 0 at $DIR/funky_arms.rs:11:35: 11:38 debug num => _2; // in scope 0 at $DIR/funky_arms.rs:11:60: 11:63 debug upper => _3; // in scope 0 at $DIR/funky_arms.rs:11:69: 11:74 diff --git a/src/test/mir-opt/inline/inline-instruction-set.rs b/src/test/mir-opt/inline/inline-instruction-set.rs new file mode 100644 index 00000000000..be36ff50c7e --- /dev/null +++ b/src/test/mir-opt/inline/inline-instruction-set.rs @@ -0,0 +1,54 @@ +// Checks that only functions with the compatible instruction_set attributes are inlined. +// +// compile-flags: --target thumbv4t-none-eabi +// needs-llvm-components: arm + +#![crate_type = "lib"] +#![feature(rustc_attrs)] +#![feature(no_core, lang_items)] +#![feature(isa_attribute)] +#![no_core] + +#[rustc_builtin_macro] +#[macro_export] +macro_rules! asm { + ("assembly template", + $(operands,)* + $(options($(option),*))? + ) => { + /* compiler built-in */ + }; +} + +#[lang = "sized"] +trait Sized {} +#[lang = "copy"] +trait Copy {} + +#[instruction_set(arm::a32)] +#[inline] +fn instruction_set_a32() {} + +#[instruction_set(arm::t32)] +#[inline] +fn instruction_set_t32() {} + +#[inline] +fn instruction_set_default() {} + +// EMIT_MIR inline_instruction_set.t32.Inline.diff +#[instruction_set(arm::t32)] +pub fn t32() { + instruction_set_a32(); + instruction_set_t32(); + // The default instruction set is currently + // conservatively assumed to be incompatible. + instruction_set_default(); +} + +// EMIT_MIR inline_instruction_set.default.Inline.diff +pub fn default() { + instruction_set_a32(); + instruction_set_t32(); + instruction_set_default(); +} diff --git a/src/test/mir-opt/inline/inline_diverging.h.Inline.diff b/src/test/mir-opt/inline/inline_diverging.h.Inline.diff index 22737381c71..07994eb3c16 100644 --- a/src/test/mir-opt/inline/inline_diverging.h.Inline.diff +++ b/src/test/mir-opt/inline/inline_diverging.h.Inline.diff @@ -5,19 +5,18 @@ let mut _0: (); // return place in scope 0 at $DIR/inline-diverging.rs:21:12: 21:12 let _1: (!, !); // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 + let mut _2: fn() -> ! {sleep}; // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 ++ let mut _7: (); // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 + let mut _8: (); // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 -+ let mut _9: (); // in scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 + scope 1 (inlined call_twice::<!, fn() -> ! {sleep}>) { // at $DIR/inline-diverging.rs:22:5: 22:22 + debug f => _2; // in scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + let _3: !; // in scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + let mut _4: &fn() -> ! {sleep}; // in scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + let mut _5: &fn() -> ! {sleep}; // in scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + let mut _6: !; // in scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 -+ let mut _7: !; // in scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + scope 2 { + debug a => _3; // in scope 2 at $DIR/inline-diverging.rs:22:5: 22:22 + scope 3 { -+ debug b => _7; // in scope 3 at $DIR/inline-diverging.rs:22:5: 22:22 ++ debug b => _6; // in scope 3 at $DIR/inline-diverging.rs:22:5: 22:22 + } + scope 6 (inlined <fn() -> ! {sleep} as Fn<()>>::call - shim(fn() -> ! {sleep})) { // at $DIR/inline-diverging.rs:22:5: 22:22 + scope 7 (inlined sleep) { // at $DIR/inline-diverging.rs:22:5: 22:22 @@ -41,12 +40,12 @@ - // mir::Constant // + span: $DIR/inline-diverging.rs:22:16: 22:21 // + literal: Const { ty: fn() -> ! {sleep}, val: Value(Scalar(<ZST>)) } -+ StorageLive(_7); // scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 ++ StorageLive(_6); // scope 0 at $DIR/inline-diverging.rs:22:5: 22:22 + StorageLive(_3); // scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + StorageLive(_4); // scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + _4 = &_2; // scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 -+ StorageLive(_8); // scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 -+ _8 = const (); // scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 ++ StorageLive(_7); // scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 ++ _7 = const (); // scope 1 at $DIR/inline-diverging.rs:22:5: 22:22 + goto -> bb1; // scope 5 at $DIR/inline-diverging.rs:22:5: 22:22 } diff --git a/src/test/mir-opt/inline/inline_instruction_set.default.Inline.diff b/src/test/mir-opt/inline/inline_instruction_set.default.Inline.diff new file mode 100644 index 00000000000..334cf5a08e2 --- /dev/null +++ b/src/test/mir-opt/inline/inline_instruction_set.default.Inline.diff @@ -0,0 +1,45 @@ +- // MIR for `default` before Inline ++ // MIR for `default` after Inline + + fn default() -> () { + let mut _0: (); // return place in scope 0 at $DIR/inline-instruction-set.rs:50:18: 50:18 + let _1: (); // in scope 0 at $DIR/inline-instruction-set.rs:51:5: 51:26 + let _2: (); // in scope 0 at $DIR/inline-instruction-set.rs:52:5: 52:26 + let _3: (); // in scope 0 at $DIR/inline-instruction-set.rs:53:5: 53:30 ++ scope 1 (inlined instruction_set_default) { // at $DIR/inline-instruction-set.rs:53:5: 53:30 ++ } + + bb0: { + StorageLive(_1); // scope 0 at $DIR/inline-instruction-set.rs:51:5: 51:26 + _1 = instruction_set_a32() -> bb1; // scope 0 at $DIR/inline-instruction-set.rs:51:5: 51:26 + // mir::Constant + // + span: $DIR/inline-instruction-set.rs:51:5: 51:24 + // + literal: Const { ty: fn() {instruction_set_a32}, val: Value(Scalar(<ZST>)) } + } + + bb1: { + StorageDead(_1); // scope 0 at $DIR/inline-instruction-set.rs:51:26: 51:27 + StorageLive(_2); // scope 0 at $DIR/inline-instruction-set.rs:52:5: 52:26 + _2 = instruction_set_t32() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:52:5: 52:26 + // mir::Constant + // + span: $DIR/inline-instruction-set.rs:52:5: 52:24 + // + literal: Const { ty: fn() {instruction_set_t32}, val: Value(Scalar(<ZST>)) } + } + + bb2: { + StorageDead(_2); // scope 0 at $DIR/inline-instruction-set.rs:52:26: 52:27 + StorageLive(_3); // scope 0 at $DIR/inline-instruction-set.rs:53:5: 53:30 +- _3 = instruction_set_default() -> bb3; // scope 0 at $DIR/inline-instruction-set.rs:53:5: 53:30 +- // mir::Constant +- // + span: $DIR/inline-instruction-set.rs:53:5: 53:28 +- // + literal: Const { ty: fn() {instruction_set_default}, val: Value(Scalar(<ZST>)) } +- } +- +- bb3: { ++ _3 = const (); // scope 1 at $DIR/inline-instruction-set.rs:53:5: 53:30 + StorageDead(_3); // scope 0 at $DIR/inline-instruction-set.rs:53:30: 53:31 + _0 = const (); // scope 0 at $DIR/inline-instruction-set.rs:50:18: 54:2 + return; // scope 0 at $DIR/inline-instruction-set.rs:54:2: 54:2 + } + } + diff --git a/src/test/mir-opt/inline/inline_instruction_set.t32.Inline.diff b/src/test/mir-opt/inline/inline_instruction_set.t32.Inline.diff new file mode 100644 index 00000000000..920b68c9daa --- /dev/null +++ b/src/test/mir-opt/inline/inline_instruction_set.t32.Inline.diff @@ -0,0 +1,47 @@ +- // MIR for `t32` before Inline ++ // MIR for `t32` after Inline + + fn t32() -> () { + let mut _0: (); // return place in scope 0 at $DIR/inline-instruction-set.rs:41:14: 41:14 + let _1: (); // in scope 0 at $DIR/inline-instruction-set.rs:42:5: 42:26 + let _2: (); // in scope 0 at $DIR/inline-instruction-set.rs:43:5: 43:26 + let _3: (); // in scope 0 at $DIR/inline-instruction-set.rs:46:5: 46:30 ++ scope 1 (inlined instruction_set_t32) { // at $DIR/inline-instruction-set.rs:43:5: 43:26 ++ } + + bb0: { + StorageLive(_1); // scope 0 at $DIR/inline-instruction-set.rs:42:5: 42:26 + _1 = instruction_set_a32() -> bb1; // scope 0 at $DIR/inline-instruction-set.rs:42:5: 42:26 + // mir::Constant + // + span: $DIR/inline-instruction-set.rs:42:5: 42:24 + // + literal: Const { ty: fn() {instruction_set_a32}, val: Value(Scalar(<ZST>)) } + } + + bb1: { + StorageDead(_1); // scope 0 at $DIR/inline-instruction-set.rs:42:26: 42:27 + StorageLive(_2); // scope 0 at $DIR/inline-instruction-set.rs:43:5: 43:26 +- _2 = instruction_set_t32() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:43:5: 43:26 +- // mir::Constant +- // + span: $DIR/inline-instruction-set.rs:43:5: 43:24 +- // + literal: Const { ty: fn() {instruction_set_t32}, val: Value(Scalar(<ZST>)) } +- } +- +- bb2: { ++ _2 = const (); // scope 1 at $DIR/inline-instruction-set.rs:43:5: 43:26 + StorageDead(_2); // scope 0 at $DIR/inline-instruction-set.rs:43:26: 43:27 + StorageLive(_3); // scope 0 at $DIR/inline-instruction-set.rs:46:5: 46:30 +- _3 = instruction_set_default() -> bb3; // scope 0 at $DIR/inline-instruction-set.rs:46:5: 46:30 ++ _3 = instruction_set_default() -> bb2; // scope 0 at $DIR/inline-instruction-set.rs:46:5: 46:30 + // mir::Constant + // + span: $DIR/inline-instruction-set.rs:46:5: 46:28 + // + literal: Const { ty: fn() {instruction_set_default}, val: Value(Scalar(<ZST>)) } + } + +- bb3: { ++ bb2: { + StorageDead(_3); // scope 0 at $DIR/inline-instruction-set.rs:46:30: 46:31 + _0 = const (); // scope 0 at $DIR/inline-instruction-set.rs:41:14: 47:2 + return; // scope 0 at $DIR/inline-instruction-set.rs:47:2: 47:2 + } + } + diff --git a/src/test/mir-opt/issue_41110.main.ElaborateDrops.after.mir b/src/test/mir-opt/issue_41110.main.ElaborateDrops.after.mir index bbbd2bcf128..7113c42b9c7 100644 --- a/src/test/mir-opt/issue_41110.main.ElaborateDrops.after.mir +++ b/src/test/mir-opt/issue_41110.main.ElaborateDrops.after.mir @@ -6,18 +6,21 @@ fn main() -> () { let mut _2: S; // in scope 0 at $DIR/issue-41110.rs:8:13: 8:14 let mut _3: S; // in scope 0 at $DIR/issue-41110.rs:8:21: 8:27 let mut _4: S; // in scope 0 at $DIR/issue-41110.rs:8:21: 8:22 + let mut _5: bool; // in scope 0 at $DIR/issue-41110.rs:8:27: 8:28 scope 1 { debug x => _1; // in scope 1 at $DIR/issue-41110.rs:8:9: 8:10 } bb0: { + _5 = const false; // scope 0 at $DIR/issue-41110.rs:8:9: 8:10 StorageLive(_1); // scope 0 at $DIR/issue-41110.rs:8:9: 8:10 StorageLive(_2); // scope 0 at $DIR/issue-41110.rs:8:13: 8:14 + _5 = const true; // scope 0 at $DIR/issue-41110.rs:8:13: 8:14 _2 = S; // scope 0 at $DIR/issue-41110.rs:8:13: 8:14 StorageLive(_3); // scope 0 at $DIR/issue-41110.rs:8:21: 8:27 StorageLive(_4); // scope 0 at $DIR/issue-41110.rs:8:21: 8:22 _4 = S; // scope 0 at $DIR/issue-41110.rs:8:21: 8:22 - _3 = S::id(move _4) -> [return: bb1, unwind: bb3]; // scope 0 at $DIR/issue-41110.rs:8:21: 8:27 + _3 = S::id(move _4) -> [return: bb1, unwind: bb4]; // scope 0 at $DIR/issue-41110.rs:8:21: 8:27 // mir::Constant // + span: $DIR/issue-41110.rs:8:23: 8:25 // + literal: Const { ty: fn(S) -> S {S::id}, val: Value(Scalar(<ZST>)) } @@ -25,7 +28,8 @@ fn main() -> () { bb1: { StorageDead(_4); // scope 0 at $DIR/issue-41110.rs:8:26: 8:27 - _1 = S::other(move _2, move _3) -> bb2; // scope 0 at $DIR/issue-41110.rs:8:13: 8:28 + _5 = const false; // scope 0 at $DIR/issue-41110.rs:8:13: 8:28 + _1 = S::other(move _2, move _3) -> [return: bb2, unwind: bb3]; // scope 0 at $DIR/issue-41110.rs:8:13: 8:28 // mir::Constant // + span: $DIR/issue-41110.rs:8:15: 8:20 // + literal: Const { ty: fn(S, S) {S::other}, val: Value(Scalar(<ZST>)) } @@ -33,6 +37,7 @@ fn main() -> () { bb2: { StorageDead(_3); // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 + _5 = const false; // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 StorageDead(_2); // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 _0 = const (); // scope 0 at $DIR/issue-41110.rs:7:11: 9:2 StorageDead(_1); // scope 0 at $DIR/issue-41110.rs:9:1: 9:2 @@ -40,10 +45,26 @@ fn main() -> () { } bb3 (cleanup): { - drop(_2) -> bb4; // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 + goto -> bb5; // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 } bb4 (cleanup): { + goto -> bb5; // scope 0 at $DIR/issue-41110.rs:8:26: 8:27 + } + + bb5 (cleanup): { + goto -> bb8; // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 + } + + bb6 (cleanup): { resume; // scope 0 at $DIR/issue-41110.rs:7:1: 9:2 } + + bb7 (cleanup): { + drop(_2) -> bb6; // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 + } + + bb8 (cleanup): { + switchInt(_5) -> [false: bb6, otherwise: bb7]; // scope 0 at $DIR/issue-41110.rs:8:27: 8:28 + } } diff --git a/src/test/mir-opt/issue_41110.test.ElaborateDrops.after.mir b/src/test/mir-opt/issue_41110.test.ElaborateDrops.after.mir index b0c7260f0f4..c4e852ca321 100644 --- a/src/test/mir-opt/issue_41110.test.ElaborateDrops.after.mir +++ b/src/test/mir-opt/issue_41110.test.ElaborateDrops.after.mir @@ -25,7 +25,7 @@ fn test() -> () { StorageLive(_3); // scope 2 at $DIR/issue-41110.rs:17:5: 17:12 StorageLive(_4); // scope 2 at $DIR/issue-41110.rs:17:10: 17:11 _4 = move _2; // scope 2 at $DIR/issue-41110.rs:17:10: 17:11 - _3 = std::mem::drop::<S>(move _4) -> [return: bb1, unwind: bb5]; // scope 2 at $DIR/issue-41110.rs:17:5: 17:12 + _3 = std::mem::drop::<S>(move _4) -> [return: bb1, unwind: bb7]; // scope 2 at $DIR/issue-41110.rs:17:5: 17:12 // mir::Constant // + span: $DIR/issue-41110.rs:17:5: 17:9 // + literal: Const { ty: fn(S) {std::mem::drop::<S>}, val: Value(Scalar(<ZST>)) } @@ -37,53 +37,65 @@ fn test() -> () { StorageLive(_5); // scope 2 at $DIR/issue-41110.rs:18:9: 18:10 _6 = const false; // scope 2 at $DIR/issue-41110.rs:18:9: 18:10 _5 = move _1; // scope 2 at $DIR/issue-41110.rs:18:9: 18:10 - goto -> bb9; // scope 2 at $DIR/issue-41110.rs:18:5: 18:6 + goto -> bb12; // scope 2 at $DIR/issue-41110.rs:18:5: 18:6 } bb2: { + goto -> bb3; // scope 2 at $DIR/issue-41110.rs:18:9: 18:10 + } + + bb3: { StorageDead(_5); // scope 2 at $DIR/issue-41110.rs:18:9: 18:10 _0 = const (); // scope 0 at $DIR/issue-41110.rs:14:15: 19:2 - drop(_2) -> [return: bb3, unwind: bb6]; // scope 1 at $DIR/issue-41110.rs:19:1: 19:2 + drop(_2) -> [return: bb4, unwind: bb9]; // scope 1 at $DIR/issue-41110.rs:19:1: 19:2 } - bb3: { + bb4: { StorageDead(_2); // scope 1 at $DIR/issue-41110.rs:19:1: 19:2 - goto -> bb4; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 + goto -> bb5; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 } - bb4: { + bb5: { _6 = const false; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 StorageDead(_1); // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 return; // scope 0 at $DIR/issue-41110.rs:19:2: 19:2 } - bb5 (cleanup): { - goto -> bb6; // scope 1 at $DIR/issue-41110.rs:19:1: 19:2 - } - bb6 (cleanup): { - goto -> bb11; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 + goto -> bb8; // scope 2 at $DIR/issue-41110.rs:18:9: 18:10 } bb7 (cleanup): { - resume; // scope 0 at $DIR/issue-41110.rs:14:1: 19:2 + goto -> bb8; // scope 2 at $DIR/issue-41110.rs:17:11: 17:12 } bb8 (cleanup): { + goto -> bb9; // scope 1 at $DIR/issue-41110.rs:19:1: 19:2 + } + + bb9 (cleanup): { + goto -> bb14; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 + } + + bb10 (cleanup): { + resume; // scope 0 at $DIR/issue-41110.rs:14:1: 19:2 + } + + bb11 (cleanup): { _2 = move _5; // scope 2 at $DIR/issue-41110.rs:18:5: 18:6 - goto -> bb5; // scope 2 at $DIR/issue-41110.rs:18:5: 18:6 + goto -> bb6; // scope 2 at $DIR/issue-41110.rs:18:5: 18:6 } - bb9: { + bb12: { _2 = move _5; // scope 2 at $DIR/issue-41110.rs:18:5: 18:6 goto -> bb2; // scope 2 at $DIR/issue-41110.rs:18:5: 18:6 } - bb10 (cleanup): { - drop(_1) -> bb7; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 + bb13 (cleanup): { + drop(_1) -> bb10; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 } - bb11 (cleanup): { - switchInt(_6) -> [false: bb7, otherwise: bb10]; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 + bb14 (cleanup): { + switchInt(_6) -> [false: bb10, otherwise: bb13]; // scope 0 at $DIR/issue-41110.rs:19:1: 19:2 } } diff --git a/src/test/mir-opt/issue_41888.main.ElaborateDrops.after.mir b/src/test/mir-opt/issue_41888.main.ElaborateDrops.after.mir index 4fc7f9daa22..488fcb5dd70 100644 --- a/src/test/mir-opt/issue_41888.main.ElaborateDrops.after.mir +++ b/src/test/mir-opt/issue_41888.main.ElaborateDrops.after.mir @@ -26,7 +26,7 @@ fn main() -> () { _8 = const false; // scope 0 at $DIR/issue-41888.rs:7:9: 7:10 StorageLive(_1); // scope 0 at $DIR/issue-41888.rs:7:9: 7:10 StorageLive(_2); // scope 1 at $DIR/issue-41888.rs:8:8: 8:14 - _2 = cond() -> [return: bb1, unwind: bb9]; // scope 1 at $DIR/issue-41888.rs:8:8: 8:14 + _2 = cond() -> [return: bb1, unwind: bb11]; // scope 1 at $DIR/issue-41888.rs:8:8: 8:14 // mir::Constant // + span: $DIR/issue-41888.rs:8:8: 8:12 // + literal: Const { ty: fn() -> bool {cond}, val: Value(Scalar(<ZST>)) } @@ -42,40 +42,44 @@ fn main() -> () { _4 = K; // scope 1 at $DIR/issue-41888.rs:9:18: 9:19 _3 = E::F(move _4); // scope 1 at $DIR/issue-41888.rs:9:13: 9:20 StorageDead(_4); // scope 1 at $DIR/issue-41888.rs:9:19: 9:20 - goto -> bb12; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 + goto -> bb14; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 } bb3: { _0 = const (); // scope 1 at $DIR/issue-41888.rs:14:6: 14:6 - goto -> bb7; // scope 1 at $DIR/issue-41888.rs:8:5: 14:6 + goto -> bb8; // scope 1 at $DIR/issue-41888.rs:8:5: 14:6 } bb4: { + goto -> bb5; // scope 1 at $DIR/issue-41888.rs:9:19: 9:20 + } + + bb5: { StorageDead(_3); // scope 1 at $DIR/issue-41888.rs:9:19: 9:20 _5 = discriminant(_1); // scope 1 at $DIR/issue-41888.rs:10:16: 10:24 - switchInt(move _5) -> [0_isize: bb6, otherwise: bb5]; // scope 1 at $DIR/issue-41888.rs:10:16: 10:24 + switchInt(move _5) -> [0_isize: bb7, otherwise: bb6]; // scope 1 at $DIR/issue-41888.rs:10:16: 10:24 } - bb5: { + bb6: { _0 = const (); // scope 1 at $DIR/issue-41888.rs:13:10: 13:10 - goto -> bb7; // scope 1 at $DIR/issue-41888.rs:10:9: 13:10 + goto -> bb8; // scope 1 at $DIR/issue-41888.rs:10:9: 13:10 } - bb6: { + bb7: { StorageLive(_6); // scope 1 at $DIR/issue-41888.rs:10:21: 10:23 _9 = const false; // scope 1 at $DIR/issue-41888.rs:10:21: 10:23 _6 = move ((_1 as F).0: K); // scope 1 at $DIR/issue-41888.rs:10:21: 10:23 _0 = const (); // scope 2 at $DIR/issue-41888.rs:10:29: 13:10 StorageDead(_6); // scope 1 at $DIR/issue-41888.rs:13:9: 13:10 - goto -> bb7; // scope 1 at $DIR/issue-41888.rs:10:9: 13:10 + goto -> bb8; // scope 1 at $DIR/issue-41888.rs:10:9: 13:10 } - bb7: { + bb8: { StorageDead(_2); // scope 1 at $DIR/issue-41888.rs:14:5: 14:6 - goto -> bb18; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + goto -> bb20; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb8: { + bb9: { _7 = const false; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 _8 = const false; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 _9 = const false; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 @@ -83,23 +87,27 @@ fn main() -> () { return; // scope 0 at $DIR/issue-41888.rs:15:2: 15:2 } - bb9 (cleanup): { - goto -> bb10; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + bb10 (cleanup): { + goto -> bb11; // scope 1 at $DIR/issue-41888.rs:9:19: 9:20 + } + + bb11 (cleanup): { + goto -> bb12; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb10 (cleanup): { + bb12 (cleanup): { resume; // scope 0 at $DIR/issue-41888.rs:6:1: 15:2 } - bb11 (cleanup): { + bb13 (cleanup): { _7 = const true; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 _8 = const true; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 _9 = const true; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 _1 = move _3; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 - goto -> bb9; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 + goto -> bb10; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 } - bb12: { + bb14: { _7 = const true; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 _8 = const true; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 _9 = const true; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 @@ -107,38 +115,38 @@ fn main() -> () { goto -> bb4; // scope 1 at $DIR/issue-41888.rs:9:9: 9:10 } - bb13: { + bb15: { _7 = const false; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 - goto -> bb8; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + goto -> bb9; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb14 (cleanup): { - goto -> bb10; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + bb16 (cleanup): { + goto -> bb12; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb15: { - drop(_1) -> [return: bb13, unwind: bb10]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + bb17: { + drop(_1) -> [return: bb15, unwind: bb12]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb16 (cleanup): { - drop(_1) -> bb10; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + bb18 (cleanup): { + drop(_1) -> bb12; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb17: { + bb19: { _10 = discriminant(_1); // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 - switchInt(move _10) -> [0_isize: bb13, otherwise: bb15]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + switchInt(move _10) -> [0_isize: bb15, otherwise: bb17]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb18: { - switchInt(_7) -> [false: bb13, otherwise: bb17]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + bb20: { + switchInt(_7) -> [false: bb15, otherwise: bb19]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb19 (cleanup): { + bb21 (cleanup): { _11 = discriminant(_1); // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 - switchInt(move _11) -> [0_isize: bb14, otherwise: bb16]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + switchInt(move _11) -> [0_isize: bb16, otherwise: bb18]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } - bb20 (cleanup): { - switchInt(_7) -> [false: bb10, otherwise: bb19]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 + bb22 (cleanup): { + switchInt(_7) -> [false: bb12, otherwise: bb21]; // scope 0 at $DIR/issue-41888.rs:15:1: 15:2 } } diff --git a/src/test/mir-opt/issue_62289.test.ElaborateDrops.before.mir b/src/test/mir-opt/issue_62289.test.ElaborateDrops.before.mir index f74cdd71919..c1421f20a0b 100644 --- a/src/test/mir-opt/issue_62289.test.ElaborateDrops.before.mir +++ b/src/test/mir-opt/issue_62289.test.ElaborateDrops.before.mir @@ -30,7 +30,7 @@ fn test() -> Option<Box<u32>> { StorageLive(_3); // scope 0 at $DIR/issue-62289.rs:9:15: 9:20 StorageLive(_4); // scope 0 at $DIR/issue-62289.rs:9:15: 9:19 _4 = Option::<u32>::None; // scope 0 at $DIR/issue-62289.rs:9:15: 9:19 - _3 = <Option<u32> as Try>::into_result(move _4) -> [return: bb1, unwind: bb10]; // scope 0 at $DIR/issue-62289.rs:9:15: 9:20 + _3 = <Option<u32> as Try>::into_result(move _4) -> [return: bb1, unwind: bb12]; // scope 0 at $DIR/issue-62289.rs:9:15: 9:20 // mir::Constant // + span: $DIR/issue-62289.rs:9:15: 9:20 // + literal: Const { ty: fn(std::option::Option<u32>) -> std::result::Result<<std::option::Option<u32> as std::ops::Try>::Ok, <std::option::Option<u32> as std::ops::Try>::Error> {<std::option::Option<u32> as std::ops::Try>::into_result}, val: Value(Scalar(<ZST>)) } @@ -48,11 +48,7 @@ fn test() -> Option<Box<u32>> { (*_2) = _10; // scope 4 at $DIR/issue-62289.rs:9:15: 9:20 StorageDead(_10); // scope 0 at $DIR/issue-62289.rs:9:19: 9:20 _1 = move _2; // scope 0 at $DIR/issue-62289.rs:9:10: 9:21 - StorageDead(_2); // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 - _0 = Option::<Box<u32>>::Some(move _1); // scope 0 at $DIR/issue-62289.rs:9:5: 9:22 - StorageDead(_1); // scope 0 at $DIR/issue-62289.rs:9:21: 9:22 - StorageDead(_3); // scope 0 at $DIR/issue-62289.rs:10:1: 10:2 - goto -> bb8; // scope 0 at $DIR/issue-62289.rs:10:2: 10:2 + drop(_2) -> [return: bb7, unwind: bb11]; // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 } bb3: { @@ -65,7 +61,7 @@ fn test() -> Option<Box<u32>> { StorageLive(_8); // scope 2 at $DIR/issue-62289.rs:9:19: 9:20 StorageLive(_9); // scope 2 at $DIR/issue-62289.rs:9:19: 9:20 _9 = _6; // scope 2 at $DIR/issue-62289.rs:9:19: 9:20 - _8 = <NoneError as From<NoneError>>::from(move _9) -> [return: bb5, unwind: bb10]; // scope 2 at $DIR/issue-62289.rs:9:19: 9:20 + _8 = <NoneError as From<NoneError>>::from(move _9) -> [return: bb5, unwind: bb12]; // scope 2 at $DIR/issue-62289.rs:9:19: 9:20 // mir::Constant // + span: $DIR/issue-62289.rs:9:19: 9:20 // + literal: Const { ty: fn(std::option::NoneError) -> std::option::NoneError {<std::option::NoneError as std::convert::From<std::option::NoneError>>::from}, val: Value(Scalar(<ZST>)) } @@ -73,7 +69,7 @@ fn test() -> Option<Box<u32>> { bb5: { StorageDead(_9); // scope 2 at $DIR/issue-62289.rs:9:19: 9:20 - _0 = <Option<Box<u32>> as Try>::from_error(move _8) -> [return: bb6, unwind: bb10]; // scope 2 at $DIR/issue-62289.rs:9:15: 9:20 + _0 = <Option<Box<u32>> as Try>::from_error(move _8) -> [return: bb6, unwind: bb12]; // scope 2 at $DIR/issue-62289.rs:9:15: 9:20 // mir::Constant // + span: $DIR/issue-62289.rs:9:15: 9:20 // + literal: Const { ty: fn(<std::option::Option<std::boxed::Box<u32>> as std::ops::Try>::Error) -> std::option::Option<std::boxed::Box<u32>> {<std::option::Option<std::boxed::Box<u32>> as std::ops::Try>::from_error}, val: Value(Scalar(<ZST>)) } @@ -82,29 +78,41 @@ fn test() -> Option<Box<u32>> { bb6: { StorageDead(_8); // scope 2 at $DIR/issue-62289.rs:9:19: 9:20 StorageDead(_6); // scope 0 at $DIR/issue-62289.rs:9:19: 9:20 - drop(_2) -> [return: bb7, unwind: bb9]; // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 + drop(_2) -> bb9; // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 } bb7: { StorageDead(_2); // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 + _0 = Option::<Box<u32>>::Some(move _1); // scope 0 at $DIR/issue-62289.rs:9:5: 9:22 + drop(_1) -> bb8; // scope 0 at $DIR/issue-62289.rs:9:21: 9:22 + } + + bb8: { + StorageDead(_1); // scope 0 at $DIR/issue-62289.rs:9:21: 9:22 + StorageDead(_3); // scope 0 at $DIR/issue-62289.rs:10:1: 10:2 + goto -> bb10; // scope 0 at $DIR/issue-62289.rs:10:2: 10:2 + } + + bb9: { + StorageDead(_2); // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 StorageDead(_1); // scope 0 at $DIR/issue-62289.rs:9:21: 9:22 StorageDead(_3); // scope 0 at $DIR/issue-62289.rs:10:1: 10:2 - goto -> bb8; // scope 0 at $DIR/issue-62289.rs:10:2: 10:2 + goto -> bb10; // scope 0 at $DIR/issue-62289.rs:10:2: 10:2 } - bb8: { + bb10: { return; // scope 0 at $DIR/issue-62289.rs:10:2: 10:2 } - bb9 (cleanup): { - drop(_0) -> bb11; // scope 0 at $DIR/issue-62289.rs:10:1: 10:2 + bb11 (cleanup): { + drop(_1) -> bb13; // scope 0 at $DIR/issue-62289.rs:9:21: 9:22 } - bb10 (cleanup): { - drop(_2) -> bb11; // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 + bb12 (cleanup): { + drop(_2) -> bb13; // scope 0 at $DIR/issue-62289.rs:9:20: 9:21 } - bb11 (cleanup): { + bb13 (cleanup): { resume; // scope 0 at $DIR/issue-62289.rs:8:1: 10:2 } } diff --git a/src/test/mir-opt/issue_73223.main.PreCodegen.32bit.diff b/src/test/mir-opt/issue_73223.main.PreCodegen.32bit.diff index 9139f2cf609..e4916a56bea 100644 --- a/src/test/mir-opt/issue_73223.main.PreCodegen.32bit.diff +++ b/src/test/mir-opt/issue_73223.main.PreCodegen.32bit.diff @@ -128,7 +128,7 @@ // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {<&i32 as std::fmt::Debug>::fmt}, val: Value(Scalar(<ZST>)) } StorageLive(_22); // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL - _22 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _23) -> bb3; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL + _22 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _23) -> bb3; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } @@ -158,7 +158,7 @@ // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {<&i32 as std::fmt::Debug>::fmt}, val: Value(Scalar(<ZST>)) } StorageLive(_25); // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL - _25 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _26) -> bb5; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL + _25 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _26) -> bb5; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } diff --git a/src/test/mir-opt/issue_73223.main.PreCodegen.64bit.diff b/src/test/mir-opt/issue_73223.main.PreCodegen.64bit.diff index 9139f2cf609..e4916a56bea 100644 --- a/src/test/mir-opt/issue_73223.main.PreCodegen.64bit.diff +++ b/src/test/mir-opt/issue_73223.main.PreCodegen.64bit.diff @@ -128,7 +128,7 @@ // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {<&i32 as std::fmt::Debug>::fmt}, val: Value(Scalar(<ZST>)) } StorageLive(_22); // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL - _22 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _23) -> bb3; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL + _22 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _23) -> bb3; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } @@ -158,7 +158,7 @@ // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {<&i32 as std::fmt::Debug>::fmt}, val: Value(Scalar(<ZST>)) } StorageLive(_25); // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL - _25 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _26) -> bb5; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL + _25 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _26) -> bb5; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } diff --git a/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.32bit.diff b/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.32bit.diff index 0eea0bf0a06..b5dd416ddb1 100644 --- a/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.32bit.diff +++ b/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.32bit.diff @@ -203,7 +203,7 @@ StorageLive(_44); // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL StorageLive(_45); // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL _45 = _38; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL - _44 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _45) -> bb5; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL + _44 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _45) -> bb5; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } @@ -252,7 +252,7 @@ StorageLive(_48); // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL StorageLive(_49); // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL _49 = _41; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL - _48 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _49) -> bb7; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL + _48 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _49) -> bb7; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } diff --git a/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.64bit.diff b/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.64bit.diff index 0eea0bf0a06..b5dd416ddb1 100644 --- a/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.64bit.diff +++ b/src/test/mir-opt/issue_73223.main.SimplifyArmIdentity.64bit.diff @@ -203,7 +203,7 @@ StorageLive(_44); // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL StorageLive(_45); // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL _45 = _38; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL - _44 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _45) -> bb5; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL + _44 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _45) -> bb5; // scope 7 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } @@ -252,7 +252,7 @@ StorageLive(_48); // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL StorageLive(_49); // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL _49 = _41; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL - _48 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _49) -> bb7; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL + _48 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> Result<(), std::fmt::Error>>(move _49) -> bb7; // scope 9 at $SRC_DIR/core/src/panic.rs:LL:COL // mir::Constant // + span: $SRC_DIR/core/src/panic.rs:LL:COL // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } diff --git a/src/test/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.mir b/src/test/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.mir index 2f95931d2b2..bbb433dbe25 100644 --- a/src/test/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.mir +++ b/src/test/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.mir @@ -28,7 +28,7 @@ fn main() -> () { bb1: { StorageDead(_3); // scope 0 at $DIR/no-spurious-drop-after-call.rs:9:33: 9:34 - _1 = std::mem::drop::<String>(move _2) -> bb2; // scope 0 at $DIR/no-spurious-drop-after-call.rs:9:5: 9:35 + _1 = std::mem::drop::<String>(move _2) -> [return: bb2, unwind: bb3]; // scope 0 at $DIR/no-spurious-drop-after-call.rs:9:5: 9:35 // mir::Constant // + span: $DIR/no-spurious-drop-after-call.rs:9:5: 9:19 // + literal: Const { ty: fn(std::string::String) {std::mem::drop::<std::string::String>}, val: Value(Scalar(<ZST>)) } @@ -41,4 +41,12 @@ fn main() -> () { _0 = const (); // scope 0 at $DIR/no-spurious-drop-after-call.rs:8:11: 10:2 return; // scope 0 at $DIR/no-spurious-drop-after-call.rs:10:2: 10:2 } + + bb3 (cleanup): { + drop(_2) -> bb4; // scope 0 at $DIR/no-spurious-drop-after-call.rs:9:34: 9:35 + } + + bb4 (cleanup): { + resume; // scope 0 at $DIR/no-spurious-drop-after-call.rs:8:1: 10:2 + } } diff --git a/src/test/mir-opt/simplify_arm.id_result.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify_arm.id_result.SimplifyArmIdentity.diff index 253e3236ff7..40c18fb7282 100644 --- a/src/test/mir-opt/simplify_arm.id_result.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify_arm.id_result.SimplifyArmIdentity.diff @@ -1,7 +1,7 @@ - // MIR for `id_result` before SimplifyArmIdentity + // MIR for `id_result` after SimplifyArmIdentity - fn id_result(_1: std::result::Result<u8, i32>) -> std::result::Result<u8, i32> { + fn id_result(_1: Result<u8, i32>) -> Result<u8, i32> { debug r => _1; // in scope 0 at $DIR/simplify-arm.rs:16:14: 16:15 let mut _0: std::result::Result<u8, i32>; // return place in scope 0 at $DIR/simplify-arm.rs:16:37: 16:52 let mut _2: isize; // in scope 0 at $DIR/simplify-arm.rs:18:9: 18:14 diff --git a/src/test/mir-opt/simplify_arm.id_result.SimplifyBranchSame.diff b/src/test/mir-opt/simplify_arm.id_result.SimplifyBranchSame.diff index 23cf43c5319..596dbabead0 100644 --- a/src/test/mir-opt/simplify_arm.id_result.SimplifyBranchSame.diff +++ b/src/test/mir-opt/simplify_arm.id_result.SimplifyBranchSame.diff @@ -1,7 +1,7 @@ - // MIR for `id_result` before SimplifyBranchSame + // MIR for `id_result` after SimplifyBranchSame - fn id_result(_1: std::result::Result<u8, i32>) -> std::result::Result<u8, i32> { + fn id_result(_1: Result<u8, i32>) -> Result<u8, i32> { debug r => _1; // in scope 0 at $DIR/simplify-arm.rs:16:14: 16:15 let mut _0: std::result::Result<u8, i32>; // return place in scope 0 at $DIR/simplify-arm.rs:16:37: 16:52 let mut _2: isize; // in scope 0 at $DIR/simplify-arm.rs:18:9: 18:14 diff --git a/src/test/mir-opt/simplify_arm.id_try.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify_arm.id_try.SimplifyArmIdentity.diff index 84d8214122a..ccb3b71817f 100644 --- a/src/test/mir-opt/simplify_arm.id_try.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify_arm.id_try.SimplifyArmIdentity.diff @@ -1,7 +1,7 @@ - // MIR for `id_try` before SimplifyArmIdentity + // MIR for `id_try` after SimplifyArmIdentity - fn id_try(_1: std::result::Result<u8, i32>) -> std::result::Result<u8, i32> { + fn id_try(_1: Result<u8, i32>) -> Result<u8, i32> { debug r => _1; // in scope 0 at $DIR/simplify-arm.rs:23:11: 23:12 let mut _0: std::result::Result<u8, i32>; // return place in scope 0 at $DIR/simplify-arm.rs:23:34: 23:49 let _2: u8; // in scope 0 at $DIR/simplify-arm.rs:24:9: 24:10 @@ -26,7 +26,7 @@ - debug t => _9; // in scope 7 at $DIR/simplify-arm.rs:24:14: 24:15 + debug t => ((_0 as Err).0: i32); // in scope 7 at $DIR/simplify-arm.rs:24:14: 24:15 } - scope 8 (inlined <std::result::Result<u8, i32> as Try>::from_error) { // at $DIR/simplify-arm.rs:24:13: 24:15 + scope 8 (inlined <Result<u8, i32> as Try>::from_error) { // at $DIR/simplify-arm.rs:24:13: 24:15 - debug v => _8; // in scope 8 at $DIR/simplify-arm.rs:24:13: 24:15 + debug v => ((_0 as Err).0: i32); // in scope 8 at $DIR/simplify-arm.rs:24:13: 24:15 let mut _12: i32; // in scope 8 at $DIR/simplify-arm.rs:24:13: 24:15 @@ -39,7 +39,7 @@ scope 5 { } } - scope 6 (inlined <std::result::Result<u8, i32> as Try>::into_result) { // at $DIR/simplify-arm.rs:24:13: 24:15 + scope 6 (inlined <Result<u8, i32> as Try>::into_result) { // at $DIR/simplify-arm.rs:24:13: 24:15 debug self => _4; // in scope 6 at $DIR/simplify-arm.rs:24:13: 24:15 } diff --git a/src/test/mir-opt/simplify_arm.id_try.SimplifyBranchSame.diff b/src/test/mir-opt/simplify_arm.id_try.SimplifyBranchSame.diff index aa050655cda..ec8ac30228e 100644 --- a/src/test/mir-opt/simplify_arm.id_try.SimplifyBranchSame.diff +++ b/src/test/mir-opt/simplify_arm.id_try.SimplifyBranchSame.diff @@ -1,7 +1,7 @@ - // MIR for `id_try` before SimplifyBranchSame + // MIR for `id_try` after SimplifyBranchSame - fn id_try(_1: std::result::Result<u8, i32>) -> std::result::Result<u8, i32> { + fn id_try(_1: Result<u8, i32>) -> Result<u8, i32> { debug r => _1; // in scope 0 at $DIR/simplify-arm.rs:23:11: 23:12 let mut _0: std::result::Result<u8, i32>; // return place in scope 0 at $DIR/simplify-arm.rs:23:34: 23:49 let _2: u8; // in scope 0 at $DIR/simplify-arm.rs:24:9: 24:10 @@ -23,7 +23,7 @@ scope 7 (inlined <i32 as From<i32>>::from) { // at $DIR/simplify-arm.rs:24:14: 24:15 debug t => ((_0 as Err).0: i32); // in scope 7 at $DIR/simplify-arm.rs:24:14: 24:15 } - scope 8 (inlined <std::result::Result<u8, i32> as Try>::from_error) { // at $DIR/simplify-arm.rs:24:13: 24:15 + scope 8 (inlined <Result<u8, i32> as Try>::from_error) { // at $DIR/simplify-arm.rs:24:13: 24:15 debug v => ((_0 as Err).0: i32); // in scope 8 at $DIR/simplify-arm.rs:24:13: 24:15 let mut _12: i32; // in scope 8 at $DIR/simplify-arm.rs:24:13: 24:15 } @@ -34,7 +34,7 @@ scope 5 { } } - scope 6 (inlined <std::result::Result<u8, i32> as Try>::into_result) { // at $DIR/simplify-arm.rs:24:13: 24:15 + scope 6 (inlined <Result<u8, i32> as Try>::into_result) { // at $DIR/simplify-arm.rs:24:13: 24:15 debug self => _4; // in scope 6 at $DIR/simplify-arm.rs:24:13: 24:15 } diff --git a/src/test/mir-opt/simplify_try.try_identity.DestinationPropagation.diff b/src/test/mir-opt/simplify_try.try_identity.DestinationPropagation.diff index 3ba0af991f6..b1bae447f9c 100644 --- a/src/test/mir-opt/simplify_try.try_identity.DestinationPropagation.diff +++ b/src/test/mir-opt/simplify_try.try_identity.DestinationPropagation.diff @@ -1,7 +1,7 @@ - // MIR for `try_identity` before DestinationPropagation + // MIR for `try_identity` after DestinationPropagation - fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i32> { + fn try_identity(_1: Result<u32, i32>) -> Result<u32, i32> { debug x => _1; // in scope 0 at $DIR/simplify_try.rs:7:17: 7:18 let mut _0: std::result::Result<u32, i32>; // return place in scope 0 at $DIR/simplify_try.rs:7:41: 7:57 let _2: u32; // in scope 0 at $DIR/simplify_try.rs:8:9: 8:10 @@ -23,7 +23,7 @@ scope 7 (inlined <i32 as From<i32>>::from) { // at $DIR/simplify_try.rs:8:14: 8:15 debug t => ((_0 as Err).0: i32); // in scope 7 at $DIR/simplify_try.rs:8:14: 8:15 } - scope 8 (inlined <std::result::Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 8 (inlined <Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 debug v => ((_0 as Err).0: i32); // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 let mut _12: i32; // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 } @@ -34,7 +34,7 @@ scope 5 { } } - scope 6 (inlined <std::result::Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 6 (inlined <Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 - debug self => _4; // in scope 6 at $DIR/simplify_try.rs:8:13: 8:15 + debug self => _0; // in scope 6 at $DIR/simplify_try.rs:8:13: 8:15 } diff --git a/src/test/mir-opt/simplify_try.try_identity.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify_try.try_identity.SimplifyArmIdentity.diff index 9c91762eb4e..df274852f68 100644 --- a/src/test/mir-opt/simplify_try.try_identity.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify_try.try_identity.SimplifyArmIdentity.diff @@ -1,7 +1,7 @@ - // MIR for `try_identity` before SimplifyArmIdentity + // MIR for `try_identity` after SimplifyArmIdentity - fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i32> { + fn try_identity(_1: Result<u32, i32>) -> Result<u32, i32> { debug x => _1; // in scope 0 at $DIR/simplify_try.rs:7:17: 7:18 let mut _0: std::result::Result<u32, i32>; // return place in scope 0 at $DIR/simplify_try.rs:7:41: 7:57 let _2: u32; // in scope 0 at $DIR/simplify_try.rs:8:9: 8:10 @@ -26,7 +26,7 @@ - debug t => _9; // in scope 7 at $DIR/simplify_try.rs:8:14: 8:15 + debug t => ((_0 as Err).0: i32); // in scope 7 at $DIR/simplify_try.rs:8:14: 8:15 } - scope 8 (inlined <std::result::Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 8 (inlined <Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 - debug v => _8; // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 + debug v => ((_0 as Err).0: i32); // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 let mut _12: i32; // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 @@ -39,7 +39,7 @@ scope 5 { } } - scope 6 (inlined <std::result::Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 6 (inlined <Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 debug self => _4; // in scope 6 at $DIR/simplify_try.rs:8:13: 8:15 } diff --git a/src/test/mir-opt/simplify_try.try_identity.SimplifyBranchSame.after.mir b/src/test/mir-opt/simplify_try.try_identity.SimplifyBranchSame.after.mir index cd8436a971e..37274691fb4 100644 --- a/src/test/mir-opt/simplify_try.try_identity.SimplifyBranchSame.after.mir +++ b/src/test/mir-opt/simplify_try.try_identity.SimplifyBranchSame.after.mir @@ -1,6 +1,6 @@ // MIR for `try_identity` after SimplifyBranchSame -fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i32> { +fn try_identity(_1: Result<u32, i32>) -> Result<u32, i32> { debug x => _1; // in scope 0 at $DIR/simplify_try.rs:7:17: 7:18 let mut _0: std::result::Result<u32, i32>; // return place in scope 0 at $DIR/simplify_try.rs:7:41: 7:57 let _2: u32; // in scope 0 at $DIR/simplify_try.rs:8:9: 8:10 @@ -22,7 +22,7 @@ fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i scope 7 (inlined <i32 as From<i32>>::from) { // at $DIR/simplify_try.rs:8:14: 8:15 debug t => ((_0 as Err).0: i32); // in scope 7 at $DIR/simplify_try.rs:8:14: 8:15 } - scope 8 (inlined <std::result::Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 8 (inlined <Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 debug v => ((_0 as Err).0: i32); // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 let mut _12: i32; // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 } @@ -33,7 +33,7 @@ fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i scope 5 { } } - scope 6 (inlined <std::result::Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 6 (inlined <Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 debug self => _4; // in scope 6 at $DIR/simplify_try.rs:8:13: 8:15 } diff --git a/src/test/mir-opt/simplify_try.try_identity.SimplifyLocals.after.mir b/src/test/mir-opt/simplify_try.try_identity.SimplifyLocals.after.mir index 73f77f35a2b..f8adcced4b3 100644 --- a/src/test/mir-opt/simplify_try.try_identity.SimplifyLocals.after.mir +++ b/src/test/mir-opt/simplify_try.try_identity.SimplifyLocals.after.mir @@ -1,6 +1,6 @@ // MIR for `try_identity` after SimplifyLocals -fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i32> { +fn try_identity(_1: Result<u32, i32>) -> Result<u32, i32> { debug x => _1; // in scope 0 at $DIR/simplify_try.rs:7:17: 7:18 let mut _0: std::result::Result<u32, i32>; // return place in scope 0 at $DIR/simplify_try.rs:7:41: 7:57 scope 1 { @@ -12,7 +12,7 @@ fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i scope 7 (inlined <i32 as From<i32>>::from) { // at $DIR/simplify_try.rs:8:14: 8:15 debug t => ((_0 as Err).0: i32); // in scope 7 at $DIR/simplify_try.rs:8:14: 8:15 } - scope 8 (inlined <std::result::Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 8 (inlined <Result<u32, i32> as Try>::from_error) { // at $DIR/simplify_try.rs:8:13: 8:15 debug v => ((_0 as Err).0: i32); // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15 } } @@ -22,7 +22,7 @@ fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i scope 5 { } } - scope 6 (inlined <std::result::Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 + scope 6 (inlined <Result<u32, i32> as Try>::into_result) { // at $DIR/simplify_try.rs:8:13: 8:15 debug self => _0; // in scope 6 at $DIR/simplify_try.rs:8:13: 8:15 } diff --git a/src/test/mir-opt/uniform_array_move_out.move_out_by_subslice.mir_map.0.mir b/src/test/mir-opt/uniform_array_move_out.move_out_by_subslice.mir_map.0.mir index 9bca5d24605..d18f6308ded 100644 --- a/src/test/mir-opt/uniform_array_move_out.move_out_by_subslice.mir_map.0.mir +++ b/src/test/mir-opt/uniform_array_move_out.move_out_by_subslice.mir_map.0.mir @@ -22,38 +22,62 @@ fn move_out_by_subslice() -> () { _3 = Box(i32); // scope 0 at $DIR/uniform_array_move_out.rs:11:14: 11:19 (*_3) = const 1_i32; // scope 0 at $DIR/uniform_array_move_out.rs:11:18: 11:19 _2 = move _3; // scope 0 at $DIR/uniform_array_move_out.rs:11:14: 11:19 + drop(_3) -> [return: bb1, unwind: bb9]; // scope 0 at $DIR/uniform_array_move_out.rs:11:18: 11:19 + } + + bb1: { StorageDead(_3); // scope 0 at $DIR/uniform_array_move_out.rs:11:18: 11:19 StorageLive(_4); // scope 0 at $DIR/uniform_array_move_out.rs:11:21: 11:26 StorageLive(_5); // scope 0 at $DIR/uniform_array_move_out.rs:11:21: 11:26 _5 = Box(i32); // scope 0 at $DIR/uniform_array_move_out.rs:11:21: 11:26 (*_5) = const 2_i32; // scope 0 at $DIR/uniform_array_move_out.rs:11:25: 11:26 _4 = move _5; // scope 0 at $DIR/uniform_array_move_out.rs:11:21: 11:26 + drop(_5) -> [return: bb2, unwind: bb8]; // scope 0 at $DIR/uniform_array_move_out.rs:11:25: 11:26 + } + + bb2: { StorageDead(_5); // scope 0 at $DIR/uniform_array_move_out.rs:11:25: 11:26 _1 = [move _2, move _4]; // scope 0 at $DIR/uniform_array_move_out.rs:11:13: 11:27 + drop(_4) -> [return: bb3, unwind: bb9]; // scope 0 at $DIR/uniform_array_move_out.rs:11:26: 11:27 + } + + bb3: { StorageDead(_4); // scope 0 at $DIR/uniform_array_move_out.rs:11:26: 11:27 + drop(_2) -> [return: bb4, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:11:26: 11:27 + } + + bb4: { StorageDead(_2); // scope 0 at $DIR/uniform_array_move_out.rs:11:26: 11:27 FakeRead(ForLet, _1); // scope 0 at $DIR/uniform_array_move_out.rs:11:9: 11:10 StorageLive(_6); // scope 1 at $DIR/uniform_array_move_out.rs:12:10: 12:17 _6 = move _1[0..2]; // scope 1 at $DIR/uniform_array_move_out.rs:12:10: 12:17 _0 = const (); // scope 0 at $DIR/uniform_array_move_out.rs:10:27: 13:2 - drop(_6) -> [return: bb1, unwind: bb3]; // scope 1 at $DIR/uniform_array_move_out.rs:13:1: 13:2 + drop(_6) -> [return: bb5, unwind: bb7]; // scope 1 at $DIR/uniform_array_move_out.rs:13:1: 13:2 } - bb1: { + bb5: { StorageDead(_6); // scope 1 at $DIR/uniform_array_move_out.rs:13:1: 13:2 - drop(_1) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/uniform_array_move_out.rs:13:1: 13:2 + drop(_1) -> [return: bb6, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:13:1: 13:2 } - bb2: { + bb6: { StorageDead(_1); // scope 0 at $DIR/uniform_array_move_out.rs:13:1: 13:2 return; // scope 0 at $DIR/uniform_array_move_out.rs:13:2: 13:2 } - bb3 (cleanup): { - drop(_1) -> bb4; // scope 0 at $DIR/uniform_array_move_out.rs:13:1: 13:2 + bb7 (cleanup): { + drop(_1) -> bb10; // scope 0 at $DIR/uniform_array_move_out.rs:13:1: 13:2 + } + + bb8 (cleanup): { + drop(_4) -> bb9; // scope 0 at $DIR/uniform_array_move_out.rs:11:26: 11:27 + } + + bb9 (cleanup): { + drop(_2) -> bb10; // scope 0 at $DIR/uniform_array_move_out.rs:11:26: 11:27 } - bb4 (cleanup): { + bb10 (cleanup): { resume; // scope 0 at $DIR/uniform_array_move_out.rs:10:1: 13:2 } } diff --git a/src/test/mir-opt/uniform_array_move_out.move_out_from_end.mir_map.0.mir b/src/test/mir-opt/uniform_array_move_out.move_out_from_end.mir_map.0.mir index c9004416f2e..eda8e5fd3af 100644 --- a/src/test/mir-opt/uniform_array_move_out.move_out_from_end.mir_map.0.mir +++ b/src/test/mir-opt/uniform_array_move_out.move_out_from_end.mir_map.0.mir @@ -22,38 +22,62 @@ fn move_out_from_end() -> () { _3 = Box(i32); // scope 0 at $DIR/uniform_array_move_out.rs:5:14: 5:19 (*_3) = const 1_i32; // scope 0 at $DIR/uniform_array_move_out.rs:5:18: 5:19 _2 = move _3; // scope 0 at $DIR/uniform_array_move_out.rs:5:14: 5:19 + drop(_3) -> [return: bb1, unwind: bb9]; // scope 0 at $DIR/uniform_array_move_out.rs:5:18: 5:19 + } + + bb1: { StorageDead(_3); // scope 0 at $DIR/uniform_array_move_out.rs:5:18: 5:19 StorageLive(_4); // scope 0 at $DIR/uniform_array_move_out.rs:5:21: 5:26 StorageLive(_5); // scope 0 at $DIR/uniform_array_move_out.rs:5:21: 5:26 _5 = Box(i32); // scope 0 at $DIR/uniform_array_move_out.rs:5:21: 5:26 (*_5) = const 2_i32; // scope 0 at $DIR/uniform_array_move_out.rs:5:25: 5:26 _4 = move _5; // scope 0 at $DIR/uniform_array_move_out.rs:5:21: 5:26 + drop(_5) -> [return: bb2, unwind: bb8]; // scope 0 at $DIR/uniform_array_move_out.rs:5:25: 5:26 + } + + bb2: { StorageDead(_5); // scope 0 at $DIR/uniform_array_move_out.rs:5:25: 5:26 _1 = [move _2, move _4]; // scope 0 at $DIR/uniform_array_move_out.rs:5:13: 5:27 + drop(_4) -> [return: bb3, unwind: bb9]; // scope 0 at $DIR/uniform_array_move_out.rs:5:26: 5:27 + } + + bb3: { StorageDead(_4); // scope 0 at $DIR/uniform_array_move_out.rs:5:26: 5:27 + drop(_2) -> [return: bb4, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:5:26: 5:27 + } + + bb4: { StorageDead(_2); // scope 0 at $DIR/uniform_array_move_out.rs:5:26: 5:27 FakeRead(ForLet, _1); // scope 0 at $DIR/uniform_array_move_out.rs:5:9: 5:10 StorageLive(_6); // scope 1 at $DIR/uniform_array_move_out.rs:6:14: 6:16 _6 = move _1[1 of 2]; // scope 1 at $DIR/uniform_array_move_out.rs:6:14: 6:16 _0 = const (); // scope 0 at $DIR/uniform_array_move_out.rs:4:24: 7:2 - drop(_6) -> [return: bb1, unwind: bb3]; // scope 1 at $DIR/uniform_array_move_out.rs:7:1: 7:2 + drop(_6) -> [return: bb5, unwind: bb7]; // scope 1 at $DIR/uniform_array_move_out.rs:7:1: 7:2 } - bb1: { + bb5: { StorageDead(_6); // scope 1 at $DIR/uniform_array_move_out.rs:7:1: 7:2 - drop(_1) -> [return: bb2, unwind: bb4]; // scope 0 at $DIR/uniform_array_move_out.rs:7:1: 7:2 + drop(_1) -> [return: bb6, unwind: bb10]; // scope 0 at $DIR/uniform_array_move_out.rs:7:1: 7:2 } - bb2: { + bb6: { StorageDead(_1); // scope 0 at $DIR/uniform_array_move_out.rs:7:1: 7:2 return; // scope 0 at $DIR/uniform_array_move_out.rs:7:2: 7:2 } - bb3 (cleanup): { - drop(_1) -> bb4; // scope 0 at $DIR/uniform_array_move_out.rs:7:1: 7:2 + bb7 (cleanup): { + drop(_1) -> bb10; // scope 0 at $DIR/uniform_array_move_out.rs:7:1: 7:2 + } + + bb8 (cleanup): { + drop(_4) -> bb9; // scope 0 at $DIR/uniform_array_move_out.rs:5:26: 5:27 + } + + bb9 (cleanup): { + drop(_2) -> bb10; // scope 0 at $DIR/uniform_array_move_out.rs:5:26: 5:27 } - bb4 (cleanup): { + bb10 (cleanup): { resume; // scope 0 at $DIR/uniform_array_move_out.rs:4:1: 7:2 } } diff --git a/src/test/run-make-fulldeps/coverage-llvmir/Makefile b/src/test/run-make-fulldeps/coverage-llvmir/Makefile index 54fc3d16864..7d9121ee2f8 100644 --- a/src/test/run-make-fulldeps/coverage-llvmir/Makefile +++ b/src/test/run-make-fulldeps/coverage-llvmir/Makefile @@ -1,4 +1,5 @@ # needs-profiler-support +# min-llvm-version: 11.0 -include ../coverage/coverage_tools.mk @@ -48,12 +49,7 @@ else -DINSTR_PROF_ORDERFILE='$(DATA_SECTION_PREFIX)__llvm_orderfile' endif -ifeq ($(LLVM_VERSION_11_PLUS),true) all: test_llvm_ir -else -$(info Rust option `-Z instrument-coverage` requires LLVM 11 or higher. Test skipped.) -all: -endif test_llvm_ir: # Compile the test program with non-experimental coverage instrumentation, and generate LLVM IR diff --git a/src/test/run-make-fulldeps/coverage-reports/Makefile b/src/test/run-make-fulldeps/coverage-reports/Makefile index f98245b4a99..a700cf68cd9 100644 --- a/src/test/run-make-fulldeps/coverage-reports/Makefile +++ b/src/test/run-make-fulldeps/coverage-reports/Makefile @@ -1,5 +1,7 @@ +# ignore-test Broken; accidentally silently ignored on Linux CI; FIXME(#81688) # needs-profiler-support # ignore-windows-gnu +# min-llvm-version: 11.0 # FIXME(mati865): MinGW GCC miscompiles compiler-rt profiling library but with Clang it works # properly. Since we only have GCC on the CI ignore the test for now. @@ -67,12 +69,7 @@ ifdef RUSTC_BLESS_TEST DEBUG_FLAG=--debug endif -ifeq ($(LLVM_VERSION_11_PLUS),true) all: $(patsubst $(SOURCEDIR)/lib/%.rs,%,$(wildcard $(SOURCEDIR)/lib/*.rs)) $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs)) -else -$(info Rust option `-Z instrument-coverage` requires LLVM 11 or higher. Test skipped.) -all: -endif # Ensure there are no `expected` results for tests that may have been removed or renamed .PHONY: clear_expected_if_blessed diff --git a/src/test/run-make-fulldeps/coverage-reports/expected_show_coverage.uses_crate.txt b/src/test/run-make-fulldeps/coverage-reports/expected_show_coverage.uses_crate.txt index 4c03e950af0..e14e733fff6 100644 --- a/src/test/run-make-fulldeps/coverage-reports/expected_show_coverage.uses_crate.txt +++ b/src/test/run-make-fulldeps/coverage-reports/expected_show_coverage.uses_crate.txt @@ -19,12 +19,12 @@ 18| 2| println!("used_only_from_bin_crate_generic_function with {:?}", arg); 19| 2|} ------------------ - | used_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>: + | used_crate::used_only_from_bin_crate_generic_function::<&str>: | 17| 1|pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) { | 18| 1| println!("used_only_from_bin_crate_generic_function with {:?}", arg); | 19| 1|} ------------------ - | used_crate::used_only_from_bin_crate_generic_function::<&str>: + | used_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>: | 17| 1|pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) { | 18| 1| println!("used_only_from_bin_crate_generic_function with {:?}", arg); | 19| 1|} diff --git a/src/test/run-make-fulldeps/coverage-spanview/Makefile b/src/test/run-make-fulldeps/coverage-spanview/Makefile index 84b5d0e522f..cd54ac0ed4c 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/Makefile +++ b/src/test/run-make-fulldeps/coverage-spanview/Makefile @@ -1,4 +1,5 @@ # needs-profiler-support +# min-llvm-version: 11.0 -include ../coverage/coverage_tools.mk @@ -20,12 +21,7 @@ For revisions in Pull Requests (PR): endef export SPANVIEW_HEADER -ifeq ($(LLVM_VERSION_11_PLUS),true) all: $(patsubst $(SOURCEDIR)/lib/%.rs,%,$(wildcard $(SOURCEDIR)/lib/*.rs)) $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs)) -else -$(info Rust option `-Z instrument-coverage` requires LLVM 11 or higher. Test skipped.) -all: -endif # Ensure there are no `expected` results for tests that may have been removed or renamed .PHONY: clear_expected_if_blessed @@ -46,6 +42,7 @@ endif echo "--edition=2018" \ ) \ --crate-type rlib \ + -Ztrim-diagnostic-paths=no \ -Zinstrument-coverage \ -Zdump-mir=InstrumentCoverage \ -Zdump-mir-spanview \ @@ -77,6 +74,7 @@ endif echo "--edition=2018" \ ) \ -L "$(TMPDIR)" \ + -Ztrim-diagnostic-paths=no \ -Zinstrument-coverage \ -Zdump-mir=InstrumentCoverage \ -Zdump-mir-spanview \ diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html index b058dce2983..a302b974ae1 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html @@ -81,10 +81,10 @@ For revisions in Pull Requests (PR): 7:9-7:33: @1[18]: _13 = &(*_32) 7:9-7:33: @1[19]: _12 = &(*_13) 7:9-7:33: @1[20]: _11 = move _12 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -7:9-7:33: @1.Call: _6 = Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] -7:9-7:33: @3.Call: _5 = _print(move _6) -> [return: bb4, unwind: bb7] +7:9-7:33: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] +7:9-7:33: @3.Call: _5 = std::io::_print(move _6) -> [return: bb4, unwind: bb7] 7:9-7:33: @4[5]: _4 = const () -8:9-8:37: @4.Call: begin_panic::<&str>(const "panics and aborts") -> bb7"><span class="annotation">@1,3,4⦊</span>println!("aborting...");</span></span> +8:9-8:37: @4.Call: std::rt::begin_panic::<&str>(const "panics and aborts") -> bb7"><span class="annotation">@1,3,4⦊</span>println!("aborting...");</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="7:18-7:31: @1[6]: _33 = const might_abort::promoted[3] 7:18-7:31: @1[7]: _9 = &(*_33) 7:18-7:31: @1[8]: _8 = &(*_9) @@ -95,10 +95,10 @@ For revisions in Pull Requests (PR): 7:9-7:33: @1[18]: _13 = &(*_32) 7:9-7:33: @1[19]: _12 = &(*_13) 7:9-7:33: @1[20]: _11 = move _12 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -7:9-7:33: @1.Call: _6 = Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] -7:9-7:33: @3.Call: _5 = _print(move _6) -> [return: bb4, unwind: bb7] +7:9-7:33: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] +7:9-7:33: @3.Call: _5 = std::io::_print(move _6) -> [return: bb4, unwind: bb7] 7:9-7:33: @4[5]: _4 = const () -8:9-8:37: @4.Call: begin_panic::<&str>(const "panics and aborts") -> bb7"> panic!("panics and aborts");<span class="annotation">⦉@1,3,4</span></span></span><span class="code" style="--layer: 0"></span></span> +8:9-8:37: @4.Call: std::rt::begin_panic::<&str>(const "panics and aborts") -> bb7"> panic!("panics and aborts");<span class="annotation">⦉@1,3,4</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> } else </span><span><span class="code even" style="--layer: 1" title="10:18-10:31: @2[6]: _31 = const might_abort::promoted[1] 10:18-10:31: @2[7]: _23 = &(*_31) 10:18-10:31: @2[8]: _22 = &(*_23) @@ -109,8 +109,8 @@ For revisions in Pull Requests (PR): 10:9-10:33: @2[18]: _27 = &(*_30) 10:9-10:33: @2[19]: _26 = &(*_27) 10:9-10:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -10:9-10:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -10:9-10:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 10:9-10:33: @6[5]: _18 = const () 9:12-11:6: @6[7]: _0 = const () 12:2-12:2: @6.Return: return"><span class="annotation">@2,5,6⦊</span>{</span></span> @@ -124,8 +124,8 @@ For revisions in Pull Requests (PR): 10:9-10:33: @2[18]: _27 = &(*_30) 10:9-10:33: @2[19]: _26 = &(*_27) 10:9-10:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -10:9-10:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -10:9-10:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 10:9-10:33: @6[5]: _18 = const () 9:12-11:6: @6[7]: _0 = const () 12:2-12:2: @6.Return: return"> println!("Don't Panic");</span></span> @@ -139,8 +139,8 @@ For revisions in Pull Requests (PR): 10:9-10:33: @2[18]: _27 = &(*_30) 10:9-10:33: @2[19]: _26 = &(*_27) 10:9-10:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -10:9-10:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -10:9-10:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 10:9-10:33: @6[5]: _18 = const () 9:12-11:6: @6[7]: _0 = const () 12:2-12:2: @6.Return: return"> }</span></span> @@ -154,8 +154,8 @@ For revisions in Pull Requests (PR): 10:9-10:33: @2[18]: _27 = &(*_30) 10:9-10:33: @2[19]: _26 = &(*_27) 10:9-10:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -10:9-10:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -10:9-10:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 10:9-10:33: @6[5]: _18 = const () 9:12-11:6: @6[7]: _0 = const () 12:2-12:2: @6.Return: return">}<span class="annotation">⦉@2,5,6</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html index 823bb0cfd84..b7f3cf0819f 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html @@ -80,13 +80,13 @@ For revisions in Pull Requests (PR): 5:5-5:48: @0[22]: _15 = (_13.0: &u32) 5:5-5:48: @0[25]: _17 = &(*_15) 5:5-5:48: @0[27]: _18 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -5:5-5:48: @0.Call: _16 = ArgumentV1::new::<u32>(move _17, move _18) -> [return: bb1, unwind: bb12] +5:5-5:48: @0.Call: _16 = std::fmt::ArgumentV1::new::<u32>(move _17, move _18) -> [return: bb1, unwind: bb12] 5:5-5:48: @1[2]: _12 = [move _16] 5:5-5:48: @1[5]: _11 = &_12 5:5-5:48: @1[6]: _10 = &(*_11) 5:5-5:48: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -5:5-5:48: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb12] -5:5-5:48: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb12] +5:5-5:48: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb12] +5:5-5:48: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb12] 5:5-5:48: @3[6]: _2 = const ()"><span class="annotation">@0,1,2,3,4⦊</span>println!("does 1 + 1 = {}?", one_plus_one);<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> assert_eq!(</span><span><span class="code even" style="--layer: 1" title="6:16-6:21: @3[11]: _23 = CheckedAdd(const 1_u32, const 1_u32)"><span class="annotation">@0,1,2,3,4⦊</span>1 + 1<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">, one_plus_one, </span><span><span class="code odd" style="--layer: 1" title="6:37-6:61: @5[28]: _70 = const might_fail_assert::promoted[1] 6:37-6:61: @5[29]: _50 = &(*_70) diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html index 0f37df23fe9..64fc1568b00 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html @@ -73,12 +73,12 @@ For revisions in Pull Requests (PR): 24:38-24:74: @1[5]: FakeRead(ForMatchedPlace, _13) 24:38-24:74: @1[7]: _25 = (_13.0: &std::fmt::Arguments) 24:38-24:74: @1[10]: _27 = &(*_25) -24:38-24:74: @1[12]: _28 = <Arguments as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::fmt::Arguments, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -24:38-24:74: @1.Call: _26 = ArgumentV1::new::<Arguments>(move _27, move _28) -> [return: bb2, unwind: bb4] +24:38-24:74: @1[12]: _28 = <std::fmt::Arguments as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::fmt::Arguments, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +24:38-24:74: @1.Call: _26 = std::fmt::ArgumentV1::new::<std::fmt::Arguments>(move _27, move _28) -> [return: bb2, unwind: bb4] 24:38-24:74: @2[2]: _12 = [move _26] 24:38-24:74: @2[5]: _11 = &_12 24:38-24:74: @2[6]: _10 = &(*_11) 24:38-24:74: @2[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -24:38-24:74: @2.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div> +24:38-24:74: @2.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html index 828b9cebd6a..1bbcfa5744b 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html @@ -73,12 +73,12 @@ For revisions in Pull Requests (PR): 24:38-24:74: @1[5]: FakeRead(ForMatchedPlace, _13) 24:38-24:74: @1[7]: _25 = (_13.0: &std::fmt::Arguments) 24:38-24:74: @1[10]: _27 = &(*_25) -24:38-24:74: @1[12]: _28 = <Arguments as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::fmt::Arguments, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -24:38-24:74: @1.Call: _26 = ArgumentV1::new::<Arguments>(move _27, move _28) -> [return: bb2, unwind: bb4] +24:38-24:74: @1[12]: _28 = <std::fmt::Arguments as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::fmt::Arguments, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +24:38-24:74: @1.Call: _26 = std::fmt::ArgumentV1::new::<std::fmt::Arguments>(move _27, move _28) -> [return: bb2, unwind: bb4] 24:38-24:74: @2[2]: _12 = [move _26] 24:38-24:74: @2[5]: _11 = &_12 24:38-24:74: @2[6]: _10 = &(*_11) 24:38-24:74: @2[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -24:38-24:74: @2.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div> +24:38-24:74: @2.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html index 28b10e59b5a..14cb98d20c9 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html @@ -73,12 +73,12 @@ For revisions in Pull Requests (PR): 24:38-24:74: @1[5]: FakeRead(ForMatchedPlace, _13) 24:38-24:74: @1[7]: _25 = (_13.0: &std::fmt::Arguments) 24:38-24:74: @1[10]: _27 = &(*_25) -24:38-24:74: @1[12]: _28 = <Arguments as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::fmt::Arguments, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -24:38-24:74: @1.Call: _26 = ArgumentV1::new::<Arguments>(move _27, move _28) -> [return: bb2, unwind: bb4] +24:38-24:74: @1[12]: _28 = <std::fmt::Arguments as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::fmt::Arguments, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +24:38-24:74: @1.Call: _26 = std::fmt::ArgumentV1::new::<std::fmt::Arguments>(move _27, move _28) -> [return: bb2, unwind: bb4] 24:38-24:74: @2[2]: _12 = [move _26] 24:38-24:74: @2[5]: _11 = &_12 24:38-24:74: @2[6]: _10 = &(*_11) 24:38-24:74: @2[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -24:38-24:74: @2.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div> +24:38-24:74: @2.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html index 19707255d07..9a5bd6e42cd 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html @@ -70,166 +70,166 @@ For revisions in Pull Requests (PR): </head> <body> <div class="code" style="counter-reset: line 109"><span class="line"> <span><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"><span class="annotation">@0,1,2,3,4,5⦊</span>pub fn block_on<F: Future>(mut future: F) -> F::Output {</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> let mut future = unsafe { Pin::new_unchecked(&mut future) };</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"></span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> static VTABLE: RawWakerVTable = RawWakerVTable::new(</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> |_| unimplemented!("clone"),</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> |_| unimplemented!("wake"),</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> |_| unimplemented!("wake_by_ref"),</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> |_| (),</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> );</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &mut _1 -111:35-111:66: @0.Call: _2 = Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb23] +111:35-111:66: @0.Call: _2 = std::pin::Pin::<&mut F>::new_unchecked(move _3) -> [return: bb1, unwind: bb20] 111:13-111:23: @1[1]: FakeRead(ForLet, _2) -119:60-119:77: @1.Call: _6 = null::<()>() -> [return: bb2, unwind: bb23] -119:80-119:86: @2[3]: _9 = const {alloc0: &RawWakerVTable} +119:60-119:77: @1.Call: _6 = std::ptr::null::<()>() -> [return: bb2, unwind: bb20] +119:80-119:86: @2[3]: _9 = const {alloc0: &std::task::RawWakerVTable} 119:79-119:86: @2[4]: _8 = &(*_9) 119:79-119:86: @2[5]: _7 = &(*_8) -119:46-119:87: @2.Call: _5 = RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb23] -119:30-119:88: @3.Call: _4 = Waker::from_raw(move _5) -> [return: bb4, unwind: bb23] +119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -> [return: bb3, unwind: bb20] +119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -> [return: bb4, unwind: bb20] 119:13-119:18: @4[1]: FakeRead(ForLet, _4) 120:47-120:53: @4[7]: _12 = &_4 120:47-120:53: @4[8]: _11 = &(*_12) -120:27-120:54: @4.Call: _10 = Context::from_waker(move _11) -> [return: bb5, unwind: bb22] +120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -> [return: bb5, unwind: bb19] 120:13-120:24: @5[1]: FakeRead(ForLet, _10)"> let mut context = Context::from_waker(&waker)<span class="annotation">⦉@0,1,2,3,4,5</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> loop {</span></span> <span class="line"><span class="code" style="--layer: 0"> if let Poll::Ready(</span><span><span class="code odd" style="--layer: 1" title="123:32-123:35: @12[1]: _20 = move ((_14 as Ready).0: <F as std::future::Future>::Output)"><span class="annotation">@10,12,14,15,16,17⦊</span>val<span class="annotation">⦉@10,12,14,15,16,17</span></span></span><span class="code" style="--layer: 0">) = </span><span><span class="code even" style="--layer: 1" title="123:39-123:45: @7[3]: _16 = &mut _2 -123:39-123:54: @7.Call: _15 = Pin::<&mut F>::as_mut(move _16) -> [return: bb8, unwind: bb22] +123:39-123:54: @7.Call: _15 = std::pin::Pin::<&mut F>::as_mut(move _16) -> [return: bb8, unwind: bb19] 123:60-123:72: @8[3]: _18 = &mut _10 123:60-123:72: @8[4]: _17 = &mut (*_18) -123:39-123:73: @8.Call: _14 = <F as Future>::poll(move _15, move _17) -> [return: bb9, unwind: bb22] +123:39-123:73: @8.Call: _14 = <F as std::future::Future>::poll(move _15, move _17) -> [return: bb9, unwind: bb19] 123:39-123:73: @9[2]: FakeRead(ForMatchedPlace, _14)"><span class="annotation">@6,7,8,9⦊</span>future.as_mut().poll(&mut context)<span class="annotation">⦉@6,7,8,9</span></span></span><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> break </span><span><span class="code odd" style="--layer: 1" title="124:23-124:26: @12[2]: _0 = move _20"><span class="annotation">@10,12,14,15,16,17⦊</span>val<span class="annotation">⦉@10,12,14,15,16,17</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="125:14-125:14: @11[0]: _13 = const ()"><span class="annotation">@11,13⦊</span>‸<span class="annotation">⦉@11,13</span></span></span><span class="code" style="--layer: 0"></span></span> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html index 611799161d3..b892af0ed37 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html @@ -69,121 +69,121 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 92"><span class="line"><span><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<div class="code" style="counter-reset: line 92"><span class="line"><span><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"> let _ = g(10);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"> let _ = h(9);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"> let mut future = Box::pin(i(8));</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"> j(7);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"> l(6);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"> let _ = m(5);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return"> executor::block_on(future.as_mut());</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb15] -95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb15] -96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb15] -96:22-96:36: @5.Call: _3 = Box::<impl Future>::pin(move _4) -> [return: bb6, unwind: bb15] +<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -> [return: bb1, unwind: bb16] +95:13-95:17: @2.Call: _2 = h(const 9_usize) -> [return: bb3, unwind: bb16] +96:31-96:35: @4.Call: _4 = i(const 8_u8) -> [return: bb5, unwind: bb16] +96:22-96:36: @5.Call: _3 = std::boxed::Box::<impl std::future::Future>::pin(move _4) -> [return: bb6, unwind: bb15] 96:9-96:19: @6[1]: FakeRead(ForLet, _3) 97:5-97:9: @6.Call: _5 = j(const 7_u8) -> [return: bb7, unwind: bb14] 98:5-98:9: @7.Call: _6 = l(const 6_u8) -> [return: bb8, unwind: bb14] 99:13-99:17: @8.Call: _7 = m(const 5_u8) -> [return: bb9, unwind: bb14] 100:24-100:30: @10[4]: _10 = &mut _3 -100:24-100:39: @10.Call: _9 = Pin::<Box<impl Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] -100:5-100:40: @11.Call: _8 = block_on::<Pin<&mut impl Future>>(move _9) -> [return: bb12, unwind: bb14] +100:24-100:39: @10.Call: _9 = std::pin::Pin::<std::boxed::Box<impl std::future::Future>>::as_mut(move _10) -> [return: bb11, unwind: bb14] +100:5-100:40: @11.Call: _8 = executor::block_on::<std::pin::Pin<&mut impl std::future::Future>>(move _9) -> [return: bb12, unwind: bb14] 93:11-101:2: @12[2]: _0 = const () 101:2-101:2: @13.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html index b4b171dc955..3998295a052 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html @@ -86,11 +86,11 @@ For revisions in Pull Requests (PR): 36:21-38:10: @1[1]: _3 = const ()"> }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="38:10-38:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="39:9-39:23: @3[4]: _6 = const "alt string 2" 39:9-39:23: @3[5]: _5 = &(*_6) -39:9-39:34: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +39:9-39:34: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 40:6-40:6: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 2".to_owned()</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="39:9-39:23: @3[4]: _6 = const "alt string 2" 39:9-39:23: @3[5]: _5 = &(*_6) -39:9-39:34: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +39:9-39:34: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 40:6-40:6: @4.Return: return"> }<span class="annotation">⦉@3,4</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html index c1edc3eb929..3bdfe71b48c 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html @@ -86,11 +86,11 @@ For revisions in Pull Requests (PR): 21:29-23:18: @1[1]: _3 = const ()"> }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="23:18-23:18: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="24:17-24:31: @3[4]: _6 = const "alt string 1" 24:17-24:31: @3[5]: _5 = &(*_6) -24:17-24:42: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +24:17-24:42: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 25:14-25:14: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 1".to_owned()</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="24:17-24:31: @3[4]: _6 = const "alt string 1" 24:17-24:31: @3[5]: _5 = &(*_6) -24:17-24:42: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +24:17-24:42: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 25:14-25:14: @4.Return: return"> }<span class="annotation">⦉@3,4</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html index 24c1cadacac..4b3f04b5a0c 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html @@ -86,11 +86,11 @@ For revisions in Pull Requests (PR): 63:29-65:18: @1[1]: _3 = const ()"> }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="65:18-65:18: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="66:17-66:31: @3[4]: _6 = const "alt string 3" 66:17-66:31: @3[5]: _5 = &(*_6) -66:17-66:42: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +66:17-66:42: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 67:14-67:14: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 3".to_owned()</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="66:17-66:31: @3[4]: _6 = const "alt string 3" 66:17-66:31: @3[5]: _5 = &(*_6) -66:17-66:42: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +66:17-66:42: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 67:14-67:14: @4.Return: return"> }<span class="annotation">⦉@3,4</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html index 7a3921c5aec..8ae494178f7 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html @@ -86,11 +86,11 @@ For revisions in Pull Requests (PR): 78:21-80:10: @1[1]: _3 = const ()"> }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="80:10-80:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="81:9-81:23: @3[4]: _6 = const "alt string 4" 81:9-81:23: @3[5]: _5 = &(*_6) -81:9-81:34: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +81:9-81:34: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 82:6-82:6: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 4".to_owned()</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="81:9-81:23: @3[4]: _6 = const "alt string 4" 81:9-81:23: @3[5]: _5 = &(*_6) -81:9-81:34: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +81:9-81:34: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 82:6-82:6: @4.Return: return"> }<span class="annotation">⦉@3,4</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html index 06b817e4318..ad40ba57d69 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html @@ -94,13 +94,13 @@ For revisions in Pull Requests (PR): 103:9-103:29: @3[23]: _18 = (_16.0: &&str) 103:9-103:29: @3[26]: _20 = &(*_18) 103:9-103:29: @3[28]: _21 = <&str as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r &str, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -103:9-103:29: @3.Call: _19 = ArgumentV1::new::<&str>(move _20, move _21) -> [return: bb4, unwind: bb9] +103:9-103:29: @3.Call: _19 = std::fmt::ArgumentV1::new::<&str>(move _20, move _21) -> [return: bb4, unwind: bb8] 103:9-103:29: @4[2]: _15 = [move _19] 103:9-103:29: @4[5]: _14 = &_15 103:9-103:29: @4[6]: _13 = &(*_14) 103:9-103:29: @4[7]: _12 = move _13 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -103:9-103:29: @4.Call: _7 = Arguments::new_v1(move _8, move _12) -> [return: bb5, unwind: bb9] -103:9-103:29: @5.Call: _6 = format(move _7) -> [return: bb6, unwind: bb9] +103:9-103:29: @4.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -> [return: bb5, unwind: bb8] +103:9-103:29: @5.Call: _6 = std::fmt::format(move _7) -> [return: bb6, unwind: bb8] 103:9-103:29: @6[1]: FakeRead(ForLet, _6) 103:9-103:29: @6[6]: _0 = move _6 104:6-104:6: @7.Return: return"><span class="annotation">@3,4,5,6,7⦊</span>format!("'{}'", val)</span></span> @@ -114,13 +114,13 @@ For revisions in Pull Requests (PR): 103:9-103:29: @3[23]: _18 = (_16.0: &&str) 103:9-103:29: @3[26]: _20 = &(*_18) 103:9-103:29: @3[28]: _21 = <&str as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r &str, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -103:9-103:29: @3.Call: _19 = ArgumentV1::new::<&str>(move _20, move _21) -> [return: bb4, unwind: bb9] +103:9-103:29: @3.Call: _19 = std::fmt::ArgumentV1::new::<&str>(move _20, move _21) -> [return: bb4, unwind: bb8] 103:9-103:29: @4[2]: _15 = [move _19] 103:9-103:29: @4[5]: _14 = &_15 103:9-103:29: @4[6]: _13 = &(*_14) 103:9-103:29: @4[7]: _12 = move _13 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -103:9-103:29: @4.Call: _7 = Arguments::new_v1(move _8, move _12) -> [return: bb5, unwind: bb9] -103:9-103:29: @5.Call: _6 = format(move _7) -> [return: bb6, unwind: bb9] +103:9-103:29: @4.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -> [return: bb5, unwind: bb8] +103:9-103:29: @5.Call: _6 = std::fmt::format(move _7) -> [return: bb6, unwind: bb8] 103:9-103:29: @6[1]: FakeRead(ForLet, _6) 103:9-103:29: @6[6]: _0 = move _6 104:6-104:6: @7.Return: return"> }<span class="annotation">⦉@3,4,5,6,7</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html index 09407758400..23101d76a8e 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html @@ -81,11 +81,11 @@ For revisions in Pull Requests (PR): 124:21-126:10: @1[1]: _3 = const ()"> }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="126:10-126:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="127:9-127:35: @3[4]: _6 = const "closure should be unused" 127:9-127:35: @3[5]: _5 = &(*_6) -127:9-127:46: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +127:9-127:46: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 128:6-128:6: @4.Return: return"><span class="annotation">@3,4⦊</span>"closure should be unused".to_owned()</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="127:9-127:35: @3[4]: _6 = const "closure should be unused" 127:9-127:35: @3[5]: _5 = &(*_6) -127:9-127:46: @3.Call: _0 = <str as ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] +127:9-127:46: @3.Call: _0 = <str as std::borrow::ToOwned>::to_owned(move _5) -> [return: bb4, unwind: bb5] 128:6-128:6: @4.Return: return"> }<span class="annotation">⦉@3,4</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html index 9ff7a13522a..8ba7a6187fd 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html @@ -79,8 +79,8 @@ For revisions in Pull Requests (PR): 112:28-112:61: @0[17]: _11 = &(*_14) 112:28-112:61: @0[18]: _10 = &(*_11) 112:28-112:61: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -112:28-112:61: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -112:9-112:62: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +112:28-112:61: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +112:9-112:62: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 111:23-113:6: @2[5]: _0 = const () 111:23-113:6: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:23-113:6: @0[5]: _15 = const main::{closure#5}::promoted[1] @@ -93,8 +93,8 @@ For revisions in Pull Requests (PR): 112:28-112:61: @0[17]: _11 = &(*_14) 112:28-112:61: @0[18]: _10 = &(*_11) 112:28-112:61: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -112:28-112:61: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -112:9-112:62: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +112:28-112:61: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +112:9-112:62: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 111:23-113:6: @2[5]: _0 = const () 111:23-113:6: @2.Return: return"> $crate::io::_print($crate::format_args_nl!($($arg)*));</span></span> <span class="line"><span class="code even" style="--layer: 1" title="111:23-113:6: @0[5]: _15 = const main::{closure#5}::promoted[1] @@ -107,8 +107,8 @@ For revisions in Pull Requests (PR): 112:28-112:61: @0[17]: _11 = &(*_14) 112:28-112:61: @0[18]: _10 = &(*_11) 112:28-112:61: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -112:28-112:61: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -112:9-112:62: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +112:28-112:61: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +112:9-112:62: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 111:23-113:6: @2[5]: _0 = const () 111:23-113:6: @2.Return: return"> }<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html index d479211aa37..74c75c6c46c 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html @@ -79,8 +79,8 @@ For revisions in Pull Requests (PR): 141:61-141:83: @0[17]: _11 = &(*_14) 141:61-141:83: @0[18]: _10 = &(*_11) 141:61-141:83: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -141:61-141:83: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -141:61-141:83: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +141:61-141:83: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +141:61-141:83: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 141:61-141:83: @2[5]: _0 = const () 141:85-141:85: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{ println!("not called") }<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html index 2734c0b2468..386fb1b9e6f 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html @@ -79,8 +79,8 @@ For revisions in Pull Requests (PR): 144:9-144:31: @0[17]: _11 = &(*_14) 144:9-144:31: @0[18]: _10 = &(*_11) 144:9-144:31: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -144:9-144:31: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -144:9-144:31: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +144:9-144:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +144:9-144:31: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 144:9-144:31: @2[5]: _0 = const () 145:6-145:6: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{</span></span> <span class="line"><span class="code even" style="--layer: 1" title="144:18-144:30: @0[5]: _15 = const main::{closure#7}::promoted[1] @@ -93,8 +93,8 @@ For revisions in Pull Requests (PR): 144:9-144:31: @0[17]: _11 = &(*_14) 144:9-144:31: @0[18]: _10 = &(*_11) 144:9-144:31: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -144:9-144:31: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -144:9-144:31: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +144:9-144:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +144:9-144:31: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 144:9-144:31: @2[5]: _0 = const () 145:6-145:6: @2.Return: return"> println!("not called")</span></span> <span class="line"><span class="code even" style="--layer: 1" title="144:18-144:30: @0[5]: _15 = const main::{closure#7}::promoted[1] @@ -107,8 +107,8 @@ For revisions in Pull Requests (PR): 144:9-144:31: @0[17]: _11 = &(*_14) 144:9-144:31: @0[18]: _10 = &(*_11) 144:9-144:31: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -144:9-144:31: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -144:9-144:31: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +144:9-144:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +144:9-144:31: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 144:9-144:31: @2[5]: _0 = const () 145:6-145:6: @2.Return: return"> }<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html index a032df54ea2..f9da6ac9dfc 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html @@ -81,8 +81,8 @@ For revisions in Pull Requests (PR): 149:9-149:31: @0[17]: _11 = &(*_14) 149:9-149:31: @0[18]: _10 = &(*_11) 149:9-149:31: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -149:9-149:31: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -149:9-149:31: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +149:9-149:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +149:9-149:31: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 149:9-149:31: @2[5]: _0 = const () 149:33-149:33: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{ println!("not called") }<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html index 3c174e03ebe..e259fc9bb67 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html @@ -81,8 +81,8 @@ For revisions in Pull Requests (PR): 153:9-153:31: @0[17]: _11 = &(*_14) 153:9-153:31: @0[18]: _10 = &(*_11) 153:9-153:31: @0[19]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -153:9-153:31: @0.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] -153:9-153:31: @1.Call: _3 = _print(move _4) -> [return: bb2, unwind: bb3] +153:9-153:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb1, unwind: bb3] +153:9-153:31: @1.Call: _3 = std::io::_print(move _4) -> [return: bb2, unwind: bb3] 153:9-153:31: @2[5]: _0 = const () 153:33-153:33: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{ println!("not called") }<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html index 3bd446b0e04..a7d1728114e 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html @@ -69,7079 +69,7079 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>fn main() {</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> // dependent conditions.</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> let is_true = std::env::args().len() == 1;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> let is_false = ! is_true;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> let is_false = ! is_true;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> let mut some_string = Some(String::from("the string content"));</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> let mut some_string = Some(String::from("the string content"));</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> println!(</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> println!(</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> "The string or alt: {}"</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> "The string or alt: {}"</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> ,</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> ,</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> some_string</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> some_string</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> .</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> .</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> unwrap_or_else</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> unwrap_or_else</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> (</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> (</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -3:11-155:2: @36[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">||</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +3:11-155:2: @41[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">||</span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> let mut countdown = 0;</span></span> <span class="line"><span class="code" style="--layer: 0"> if is_false {</span></span> <span class="line"><span class="code" style="--layer: 0"> countdown = 10;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> "alt string 1".to_owned()</span></span> -<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"> )</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"> )</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"> );</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"> );</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"> some_string = Some(String::from("the string content"));</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"> some_string = Some(String::from("the string content"));</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"> let</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"> let</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"> a</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"> a</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"> =</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"> =</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -3:11-155:2: @36[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">||</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +3:11-155:2: @41[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">||</span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> let mut countdown = 0;</span></span> <span class="line"><span class="code" style="--layer: 0"> if is_false {</span></span> <span class="line"><span class="code" style="--layer: 0"> countdown = 10;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> "alt string 2".to_owned()</span></span> -<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> println!(</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> println!(</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> "The string or alt: {}"</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> "The string or alt: {}"</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> ,</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> ,</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> some_string</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> some_string</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> .</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> .</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> unwrap_or_else</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> unwrap_or_else</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> (</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> (</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> a</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> a</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> )</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> )</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> );</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> );</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> some_string = None;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> some_string = None;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> println!(</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> println!(</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> "The string or alt: {}"</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> "The string or alt: {}"</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> ,</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> ,</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> some_string</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> some_string</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> .</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> .</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> unwrap_or_else</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> unwrap_or_else</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> (</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> (</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -3:11-155:2: @36[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">||</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +3:11-155:2: @41[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">||</span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> let mut countdown = 0;</span></span> <span class="line"><span class="code" style="--layer: 0"> if is_false {</span></span> <span class="line"><span class="code" style="--layer: 0"> countdown = 10;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> "alt string 3".to_owned()</span></span> -<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"> )</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"> )</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"> );</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"> );</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"> some_string = None;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"> some_string = None;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"> let</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"> let</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"> a</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"> a</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"> =</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"> =</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -3:11-155:2: @36[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">||</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +3:11-155:2: @41[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">||</span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> let mut countdown = 0;</span></span> <span class="line"><span class="code" style="--layer: 0"> if is_false {</span></span> <span class="line"><span class="code" style="--layer: 0"> countdown = 10;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> "alt string 4".to_owned()</span></span> -<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> println!(</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> println!(</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> "The string or alt: {}"</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> "The string or alt: {}"</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> ,</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> ,</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> some_string</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> some_string</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> .</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> .</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> unwrap_or_else</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> unwrap_or_else</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> (</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> (</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> a</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> a</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> )</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> )</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> );</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> );</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> let</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> let</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> quote_closure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> quote_closure</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> =</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> =</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -3:11-155:2: @36[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">|val|</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +3:11-155:2: @41[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|val|</span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> let mut countdown = 0;</span></span> <span class="line"><span class="code" style="--layer: 0"> if is_false {</span></span> <span class="line"><span class="code" style="--layer: 0"> countdown = 10;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> format!("'{}'", val)</span></span> -<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> println!(</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> println!(</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> "Repeated, quoted string: {:?}"</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> "Repeated, quoted string: {:?}"</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> ,</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> ,</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> std::iter::repeat("repeat me")</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> std::iter::repeat("repeat me")</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> .take(5)</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> .take(5)</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> .map</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> .map</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> (</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> (</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> quote_closure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> quote_closure</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> )</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> )</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> .collect::<Vec<_>>()</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> .collect::<Vec<_>>()</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> );</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> );</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> let</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> let</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> _unused_closure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> _unused_closure</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> =</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> =</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -3:11-155:2: @36[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">|</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +3:11-155:2: @41[38]: _0 = const ()"> <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|</span></span> <span class="line"><span class="code" style="--layer: 0"> mut countdown</span></span> <span class="line"><span class="code" style="--layer: 0"> |</span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> @@ -7149,3773 +7149,3773 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> countdown = 10;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> "closure should be unused".to_owned()</span></span> -<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -3:11-155:2: @36[38]: _0 = const ()"> let mut countdown = 10;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +3:11-155:2: @41[38]: _0 = const ()"> let mut countdown = 10;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -3:11-155:2: @36[38]: _0 = const ()"> let _short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | countdown += 1</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +3:11-155:2: @41[38]: _0 = const ()"> let _short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | countdown += 1</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -3:11-155:2: @36[38]: _0 = const ()"> // Macros can sometimes confuse the coverage results. Compare this next assignment, with an</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +3:11-155:2: @41[38]: _0 = const ()"> // Macros can sometimes confuse the coverage results. Compare this next assignment, with an</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -3:11-155:2: @36[38]: _0 = const ()"> // unused closure that invokes the `println!()` macro, with the closure assignment above, that</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +3:11-155:2: @41[38]: _0 = const ()"> // unused closure that invokes the `println!()` macro, with the closure assignment above, that</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -3:11-155:2: @36[38]: _0 = const ()"> // does not use a macro. The closure above correctly shows `0` executions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +3:11-155:2: @41[38]: _0 = const ()"> // does not use a macro. The closure above correctly shows `0` executions.</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -3:11-155:2: @36[38]: _0 = const ()"> let _short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | println!("not called")</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +3:11-155:2: @41[38]: _0 = const ()"> let _short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | println!("not called")</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -3:11-155:2: @36[38]: _0 = const ()"> // The closure assignment above is executed, with a line count of `1`, but the `println!()`</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +3:11-155:2: @41[38]: _0 = const ()"> // The closure assignment above is executed, with a line count of `1`, but the `println!()`</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -3:11-155:2: @36[38]: _0 = const ()"> // could not have been called, and yet, there is no indication that it wasn't...</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +3:11-155:2: @41[38]: _0 = const ()"> // could not have been called, and yet, there is no indication that it wasn't...</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -3:11-155:2: @36[38]: _0 = const ()"> // ...but adding block braces gives the expected result, showing the block was not executed.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +3:11-155:2: @41[38]: _0 = const ()"> // ...but adding block braces gives the expected result, showing the block was not executed.</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -3:11-155:2: @36[38]: _0 = const ()"> let _short_unused_closure_block = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +3:11-155:2: @41[38]: _0 = const ()"> let _short_unused_closure_block = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -3:11-155:2: @36[38]: _0 = const ()"> let _shortish_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | {</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +3:11-155:2: @41[38]: _0 = const ()"> let _shortish_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | {</span></span> <span class="line"><span class="code" style="--layer: 0"> println!("not called")</span></span> -<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -3:11-155:2: @36[38]: _0 = const ()"> let _as_short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">|</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +3:11-155:2: @41[38]: _0 = const ()"> let _as_short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|</span></span> <span class="line"><span class="code" style="--layer: 0"> _unused_arg: u8</span></span> -<span class="line"><span class="code" style="--layer: 0"> | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -151:9-151:40: @36[37]: FakeRead(ForLet, _132) -3:11-155:2: @36[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span>;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +151:9-151:40: @41[37]: FakeRead(ForLet, _132) +3:11-155:2: @41[38]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span>;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -151:9-151:40: @36[37]: FakeRead(ForLet, _132) -3:11-155:2: @36[38]: _0 = const ()"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +151:9-151:40: @41[37]: FakeRead(ForLet, _132) +3:11-155:2: @41[38]: _0 = const ()"></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -151:9-151:40: @36[37]: FakeRead(ForLet, _132) -3:11-155:2: @36[38]: _0 = const ()"> let _almost_as_short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span><span class="code" style="--layer: 0">|</span></span> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +151:9-151:40: @41[37]: FakeRead(ForLet, _132) +3:11-155:2: @41[38]: _0 = const ()"> let _almost_as_short_unused_closure = <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|</span></span> <span class="line"><span class="code" style="--layer: 0"> _unused_arg: u8</span></span> -<span class="line"><span class="code" style="--layer: 0"> | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +<span class="line"><span class="code" style="--layer: 0"> | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -151:9-151:40: @36[37]: FakeRead(ForLet, _132) -3:11-155:2: @36[38]: _0 = const () -155:2-155:2: @37.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37⦊</span></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +151:9-151:40: @41[37]: FakeRead(ForLet, _132) +3:11-155:2: @41[38]: _0 = const () +155:2-155:2: @42.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42⦊</span></span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -151:9-151:40: @36[37]: FakeRead(ForLet, _132) -3:11-155:2: @36[38]: _0 = const () -155:2-155:2: @37.Return: return"> ;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb45] +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +151:9-151:40: @41[37]: FakeRead(ForLet, _132) +3:11-155:2: @41[38]: _0 = const () +155:2-155:2: @42.Return: return"> ;</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb57] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb44] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb56] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 8:22-8:29: @3[3]: _6 = _1 8:20-8:29: @3[4]: _5 = Not(move _6) 8:9-8:17: @3[6]: FakeRead(ForLet, _5) -10:32-10:66: @3.Call: _8 = <String as From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb45] -10:27-10:67: @4[0]: _7 = Option::<String>::Some(move _8) -10:9-10:24: @4[2]: FakeRead(ForLet, _7) -12:9-12:32: @4[9]: _137 = const main::promoted[4] -12:9-12:32: @4[10]: _14 = &(*_137) -12:9-12:32: @4[11]: _13 = &(*_14) -12:9-12:32: @4[12]: _12 = move _13 as &[&str] (Pointer(Unsize)) -14:9-14:20: @4[22]: _23 = move _7 -14:9-26:10: @4.Call: _22 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb5, unwind: bb43] -14:9-26:10: @5[2]: _21 = &_22 -11:5-27:7: @5[3]: _20 = (move _21,) -11:5-27:7: @5[5]: FakeRead(ForMatchedPlace, _20) -11:5-27:7: @5[7]: _26 = (_20.0: &std::string::String) -11:5-27:7: @5[10]: _28 = &(*_26) -11:5-27:7: @5[12]: _29 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -11:5-27:7: @5.Call: _27 = ArgumentV1::new::<String>(move _28, move _29) -> [return: bb6, unwind: bb42] -11:5-27:7: @6[2]: _19 = [move _27] -11:5-27:7: @6[5]: _18 = &_19 -11:5-27:7: @6[6]: _17 = &(*_18) -11:5-27:7: @6[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-27:7: @6.Call: _11 = Arguments::new_v1(move _12, move _16) -> [return: bb7, unwind: bb42] -11:5-27:7: @7.Call: _10 = _print(move _11) -> [return: bb8, unwind: bb42] -11:5-27:7: @9[6]: _9 = const () -29:24-29:58: @9.Call: _31 = <String as From<&str>>::from(const "the string content") -> [return: bb10, unwind: bb43] -29:19-29:59: @10[0]: _30 = Option::<String>::Some(move _31) -33:9-40:6: @11[3]: _33 = &_5 -31:9-31:10: @11[6]: FakeRead(ForLet, _32) -42:9-42:32: @11[13]: _136 = const main::promoted[3] -42:9-42:32: @11[14]: _39 = &(*_136) -42:9-42:32: @11[15]: _38 = &(*_39) -42:9-42:32: @11[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) -44:9-44:20: @11[26]: _48 = move _7 -48:13-48:14: @11[28]: _49 = _32 -44:9-49:10: @11.Call: _47 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb12, unwind: bb43] -44:9-49:10: @12[2]: _46 = &_47 -41:5-50:7: @12[3]: _45 = (move _46,) -41:5-50:7: @12[5]: FakeRead(ForMatchedPlace, _45) -41:5-50:7: @12[7]: _50 = (_45.0: &std::string::String) -41:5-50:7: @12[10]: _52 = &(*_50) -41:5-50:7: @12[12]: _53 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -41:5-50:7: @12.Call: _51 = ArgumentV1::new::<String>(move _52, move _53) -> [return: bb13, unwind: bb41] -41:5-50:7: @13[2]: _44 = [move _51] -41:5-50:7: @13[5]: _43 = &_44 -41:5-50:7: @13[6]: _42 = &(*_43) -41:5-50:7: @13[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -41:5-50:7: @13.Call: _36 = Arguments::new_v1(move _37, move _41) -> [return: bb14, unwind: bb41] -41:5-50:7: @14.Call: _35 = _print(move _36) -> [return: bb15, unwind: bb41] -41:5-50:7: @16[6]: _34 = const () -52:19-52:23: @16[9]: _54 = Option::<String>::None -54:9-54:32: @17[7]: _135 = const main::promoted[2] -54:9-54:32: @17[8]: _60 = &(*_135) -54:9-54:32: @17[9]: _59 = &(*_60) -54:9-54:32: @17[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) -56:9-56:20: @17[20]: _69 = move _7 -56:9-68:10: @17.Call: _68 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb18, unwind: bb43] -56:9-68:10: @18[2]: _67 = &_68 -53:5-69:7: @18[3]: _66 = (move _67,) -53:5-69:7: @18[5]: FakeRead(ForMatchedPlace, _66) -53:5-69:7: @18[7]: _72 = (_66.0: &std::string::String) -53:5-69:7: @18[10]: _74 = &(*_72) -53:5-69:7: @18[12]: _75 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -53:5-69:7: @18.Call: _73 = ArgumentV1::new::<String>(move _74, move _75) -> [return: bb19, unwind: bb40] -53:5-69:7: @19[2]: _65 = [move _73] -53:5-69:7: @19[5]: _64 = &_65 -53:5-69:7: @19[6]: _63 = &(*_64) -53:5-69:7: @19[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -53:5-69:7: @19.Call: _57 = Arguments::new_v1(move _58, move _62) -> [return: bb20, unwind: bb40] -53:5-69:7: @20.Call: _56 = _print(move _57) -> [return: bb21, unwind: bb40] -53:5-69:7: @22[6]: _55 = const () -71:19-71:23: @22[9]: _76 = Option::<String>::None -75:9-82:6: @23[3]: _78 = &_5 -73:9-73:10: @23[6]: FakeRead(ForLet, _77) -84:9-84:32: @23[13]: _134 = const main::promoted[1] -84:9-84:32: @23[14]: _84 = &(*_134) -84:9-84:32: @23[15]: _83 = &(*_84) -84:9-84:32: @23[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) -86:9-86:20: @23[26]: _93 = move _7 -90:13-90:14: @23[28]: _94 = _77 -86:9-91:10: @23.Call: _92 = Option::<String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb24, unwind: bb43] -86:9-91:10: @24[2]: _91 = &_92 -83:5-92:7: @24[3]: _90 = (move _91,) -83:5-92:7: @24[5]: FakeRead(ForMatchedPlace, _90) -83:5-92:7: @24[7]: _95 = (_90.0: &std::string::String) -83:5-92:7: @24[10]: _97 = &(*_95) -83:5-92:7: @24[12]: _98 = <String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -83:5-92:7: @24.Call: _96 = ArgumentV1::new::<String>(move _97, move _98) -> [return: bb25, unwind: bb39] -83:5-92:7: @25[2]: _89 = [move _96] -83:5-92:7: @25[5]: _88 = &_89 -83:5-92:7: @25[6]: _87 = &(*_88) -83:5-92:7: @25[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -83:5-92:7: @25.Call: _81 = Arguments::new_v1(move _82, move _86) -> [return: bb26, unwind: bb39] -83:5-92:7: @26.Call: _80 = _print(move _81) -> [return: bb27, unwind: bb39] -83:5-92:7: @28[6]: _79 = const () -97:9-104:6: @28[10]: _100 = &_5 -95:9-95:22: @28[13]: FakeRead(ForLet, _99) -106:9-106:40: @28[20]: _133 = const main::promoted[0] -106:9-106:40: @28[21]: _106 = &(*_133) -106:9-106:40: @28[22]: _105 = &(*_106) -106:9-106:40: @28[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) -108:9-108:39: @28.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb29, unwind: bb43] -108:9-109:21: @29.Call: _116 = <std::iter::Repeat<&str> as Iterator>::take(move _117, const 5_usize) -> [return: bb30, unwind: bb43] -112:13-112:26: @30[2]: _118 = _99 -108:9-113:10: @30.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as Iterator>::map::<String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb31, unwind: bb43] -108:9-114:33: @31.Call: _114 = <Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as Iterator>::collect::<Vec<String>>(move _115) -> [return: bb32, unwind: bb43] -108:9-114:33: @32[1]: _113 = &_114 -105:5-115:7: @32[2]: _112 = (move _113,) -105:5-115:7: @32[4]: FakeRead(ForMatchedPlace, _112) -105:5-115:7: @32[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) -105:5-115:7: @32[9]: _121 = &(*_119) -105:5-115:7: @32[11]: _122 = <Vec<String> as Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -105:5-115:7: @32.Call: _120 = ArgumentV1::new::<Vec<String>>(move _121, move _122) -> [return: bb33, unwind: bb38] -105:5-115:7: @33[2]: _111 = [move _120] -105:5-115:7: @33[5]: _110 = &_111 -105:5-115:7: @33[6]: _109 = &(*_110) -105:5-115:7: @33[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -105:5-115:7: @33.Call: _103 = Arguments::new_v1(move _104, move _108) -> [return: bb34, unwind: bb38] -105:5-115:7: @34.Call: _102 = _print(move _103) -> [return: bb35, unwind: bb38] -105:5-115:7: @36[6]: _101 = const () -118:9-118:24: @36[13]: FakeRead(ForLet, _123) -130:25-130:27: @36[15]: _125 = const 10_i32 -130:9-130:22: @36[16]: FakeRead(ForLet, _125) -131:33-131:67: @36[19]: _127 = &mut _125 -131:9-131:30: @36[22]: FakeRead(ForLet, _126) -136:9-136:30: @36[25]: FakeRead(ForLet, _128) -141:9-141:36: @36[28]: FakeRead(ForLet, _129) -143:9-143:33: @36[31]: FakeRead(ForLet, _130) -147:9-147:33: @36[34]: FakeRead(ForLet, _131) -151:9-151:40: @36[37]: FakeRead(ForLet, _132) -3:11-155:2: @36[38]: _0 = const () -155:2-155:2: @37.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37</span></span></span></span></div> +10:32-10:66: @3.Call: _8 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb4, unwind: bb57] +10:27-10:67: @4[0]: _7 = std::option::Option::<std::string::String>::Some(move _8) +10:9-10:24: @5[1]: FakeRead(ForLet, _7) +12:9-12:32: @5[8]: _137 = const main::promoted[4] +12:9-12:32: @5[9]: _14 = &(*_137) +12:9-12:32: @5[10]: _13 = &(*_14) +12:9-12:32: @5[11]: _12 = move _13 as &[&str] (Pointer(Unsize)) +14:9-14:20: @5[21]: _23 = move _7 +14:9-26:10: @5.Call: _22 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:18:13: 25:14]>(move _23, move _24) -> [return: bb6, unwind: bb54] +14:9-26:10: @6[2]: _21 = &_22 +11:5-27:7: @6[3]: _20 = (move _21,) +11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20) +11:5-27:7: @6[7]: _26 = (_20.0: &std::string::String) +11:5-27:7: @6[10]: _28 = &(*_26) +11:5-27:7: @6[12]: _29 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +11:5-27:7: @6.Call: _27 = std::fmt::ArgumentV1::new::<std::string::String>(move _28, move _29) -> [return: bb7, unwind: bb53] +11:5-27:7: @7[2]: _19 = [move _27] +11:5-27:7: @7[5]: _18 = &_19 +11:5-27:7: @7[6]: _17 = &(*_18) +11:5-27:7: @7[7]: _16 = move _17 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +11:5-27:7: @7.Call: _11 = std::fmt::Arguments::new_v1(move _12, move _16) -> [return: bb8, unwind: bb53] +11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -> [return: bb9, unwind: bb53] +11:5-27:7: @10[6]: _9 = const () +29:24-29:58: @10.Call: _31 = <std::string::String as std::convert::From<&str>>::from(const "the string content") -> [return: bb11, unwind: bb55] +29:19-29:59: @11[0]: _30 = std::option::Option::<std::string::String>::Some(move _31) +33:9-40:6: @14[3]: _33 = &_5 +31:9-31:10: @14[6]: FakeRead(ForLet, _32) +42:9-42:32: @14[13]: _136 = const main::promoted[3] +42:9-42:32: @14[14]: _39 = &(*_136) +42:9-42:32: @14[15]: _38 = &(*_39) +42:9-42:32: @14[16]: _37 = move _38 as &[&str] (Pointer(Unsize)) +44:9-44:20: @14[26]: _48 = move _7 +48:13-48:14: @14[28]: _49 = _32 +44:9-49:10: @14.Call: _47 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:33:9: 40:6]>(move _48, move _49) -> [return: bb15, unwind: bb51] +44:9-49:10: @15[2]: _46 = &_47 +41:5-50:7: @15[3]: _45 = (move _46,) +41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45) +41:5-50:7: @15[7]: _50 = (_45.0: &std::string::String) +41:5-50:7: @15[10]: _52 = &(*_50) +41:5-50:7: @15[12]: _53 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +41:5-50:7: @15.Call: _51 = std::fmt::ArgumentV1::new::<std::string::String>(move _52, move _53) -> [return: bb16, unwind: bb50] +41:5-50:7: @16[2]: _44 = [move _51] +41:5-50:7: @16[5]: _43 = &_44 +41:5-50:7: @16[6]: _42 = &(*_43) +41:5-50:7: @16[7]: _41 = move _42 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +41:5-50:7: @16.Call: _36 = std::fmt::Arguments::new_v1(move _37, move _41) -> [return: bb17, unwind: bb50] +41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -> [return: bb18, unwind: bb50] +41:5-50:7: @19[6]: _34 = const () +52:19-52:23: @19[9]: _54 = std::option::Option::<std::string::String>::None +54:9-54:32: @21[7]: _135 = const main::promoted[2] +54:9-54:32: @21[8]: _60 = &(*_135) +54:9-54:32: @21[9]: _59 = &(*_60) +54:9-54:32: @21[10]: _58 = move _59 as &[&str] (Pointer(Unsize)) +56:9-56:20: @21[20]: _69 = move _7 +56:9-68:10: @21.Call: _68 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:60:13: 67:14]>(move _69, move _70) -> [return: bb22, unwind: bb48] +56:9-68:10: @22[2]: _67 = &_68 +53:5-69:7: @22[3]: _66 = (move _67,) +53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66) +53:5-69:7: @22[7]: _72 = (_66.0: &std::string::String) +53:5-69:7: @22[10]: _74 = &(*_72) +53:5-69:7: @22[12]: _75 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +53:5-69:7: @22.Call: _73 = std::fmt::ArgumentV1::new::<std::string::String>(move _74, move _75) -> [return: bb23, unwind: bb47] +53:5-69:7: @23[2]: _65 = [move _73] +53:5-69:7: @23[5]: _64 = &_65 +53:5-69:7: @23[6]: _63 = &(*_64) +53:5-69:7: @23[7]: _62 = move _63 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +53:5-69:7: @23.Call: _57 = std::fmt::Arguments::new_v1(move _58, move _62) -> [return: bb24, unwind: bb47] +53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -> [return: bb25, unwind: bb47] +53:5-69:7: @26[6]: _55 = const () +71:19-71:23: @26[9]: _76 = std::option::Option::<std::string::String>::None +75:9-82:6: @28[3]: _78 = &_5 +73:9-73:10: @28[6]: FakeRead(ForLet, _77) +84:9-84:32: @28[13]: _134 = const main::promoted[1] +84:9-84:32: @28[14]: _84 = &(*_134) +84:9-84:32: @28[15]: _83 = &(*_84) +84:9-84:32: @28[16]: _82 = move _83 as &[&str] (Pointer(Unsize)) +86:9-86:20: @28[26]: _93 = move _7 +90:13-90:14: @28[28]: _94 = _77 +86:9-91:10: @28.Call: _92 = std::option::Option::<std::string::String>::unwrap_or_else::<[closure@../coverage/closure.rs:75:9: 82:6]>(move _93, move _94) -> [return: bb29, unwind: bb45] +86:9-91:10: @29[2]: _91 = &_92 +83:5-92:7: @29[3]: _90 = (move _91,) +83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90) +83:5-92:7: @29[7]: _95 = (_90.0: &std::string::String) +83:5-92:7: @29[10]: _97 = &(*_95) +83:5-92:7: @29[12]: _98 = <std::string::String as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r std::string::String, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +83:5-92:7: @29.Call: _96 = std::fmt::ArgumentV1::new::<std::string::String>(move _97, move _98) -> [return: bb30, unwind: bb44] +83:5-92:7: @30[2]: _89 = [move _96] +83:5-92:7: @30[5]: _88 = &_89 +83:5-92:7: @30[6]: _87 = &(*_88) +83:5-92:7: @30[7]: _86 = move _87 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +83:5-92:7: @30.Call: _81 = std::fmt::Arguments::new_v1(move _82, move _86) -> [return: bb31, unwind: bb44] +83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -> [return: bb32, unwind: bb44] +83:5-92:7: @33[6]: _79 = const () +97:9-104:6: @33[10]: _100 = &_5 +95:9-95:22: @33[13]: FakeRead(ForLet, _99) +106:9-106:40: @33[20]: _133 = const main::promoted[0] +106:9-106:40: @33[21]: _106 = &(*_133) +106:9-106:40: @33[22]: _105 = &(*_106) +106:9-106:40: @33[23]: _104 = move _105 as &[&str] (Pointer(Unsize)) +108:9-108:39: @33.Call: _117 = std::iter::repeat::<&str>(const "repeat me") -> [return: bb34, unwind: bb55] +108:9-109:21: @34.Call: _116 = <std::iter::Repeat<&str> as std::iter::Iterator>::take(move _117, const 5_usize) -> [return: bb35, unwind: bb55] +112:13-112:26: @35[2]: _118 = _99 +108:9-113:10: @35.Call: _115 = <std::iter::Take<std::iter::Repeat<&str>> as std::iter::Iterator>::map::<std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]>(move _116, move _118) -> [return: bb36, unwind: bb55] +108:9-114:33: @36.Call: _114 = <std::iter::Map<std::iter::Take<std::iter::Repeat<&str>>, [closure@../coverage/closure.rs:97:9: 104:6]> as std::iter::Iterator>::collect::<std::vec::Vec<std::string::String>>(move _115) -> [return: bb37, unwind: bb55] +108:9-114:33: @37[1]: _113 = &_114 +105:5-115:7: @37[2]: _112 = (move _113,) +105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112) +105:5-115:7: @37[6]: _119 = (_112.0: &std::vec::Vec<std::string::String>) +105:5-115:7: @37[9]: _121 = &(*_119) +105:5-115:7: @37[11]: _122 = <std::vec::Vec<std::string::String> as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r std::vec::Vec<std::string::String>, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::<std::vec::Vec<std::string::String>>(move _121, move _122) -> [return: bb38, unwind: bb43] +105:5-115:7: @38[2]: _111 = [move _120] +105:5-115:7: @38[5]: _110 = &_111 +105:5-115:7: @38[6]: _109 = &(*_110) +105:5-115:7: @38[7]: _108 = move _109 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) +105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -> [return: bb39, unwind: bb43] +105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -> [return: bb40, unwind: bb43] +105:5-115:7: @41[6]: _101 = const () +118:9-118:24: @41[13]: FakeRead(ForLet, _123) +130:25-130:27: @41[15]: _125 = const 10_i32 +130:9-130:22: @41[16]: FakeRead(ForLet, _125) +131:33-131:67: @41[19]: _127 = &mut _125 +131:9-131:30: @41[22]: FakeRead(ForLet, _126) +136:9-136:30: @41[25]: FakeRead(ForLet, _128) +141:9-141:36: @41[28]: FakeRead(ForLet, _129) +143:9-143:33: @41[31]: FakeRead(ForLet, _130) +147:9-147:33: @41[34]: FakeRead(ForLet, _131) +151:9-151:40: @41[37]: FakeRead(ForLet, _132) +3:11-155:2: @41[38]: _0 = const () +155:2-155:2: @42.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html index 184dba6abd1..0aa6fe65686 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html @@ -87,10 +87,10 @@ For revisions in Pull Requests (PR): 10:16-10:29: @3[6]: _5 = Gt(move _6, const 7_u32)"><span class="annotation">@3⦊</span>countdown > 7<span class="annotation">⦉@3</span></span></span><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="11:9-11:23: @4[0]: _7 = CheckedSub(_1, const 4_u32) 11:9-11:23: @6[0]: _1 = move (_7.0: u32) -12:9-12:10: @6[1]: _4 = const B"><span class="annotation">@4,6⦊</span>countdown -= 4;</span></span> +12:9-12:10: @6[1]: _4 = const main::B"><span class="annotation">@4,6⦊</span>countdown -= 4;</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @4[0]: _7 = CheckedSub(_1, const 4_u32) 11:9-11:23: @6[0]: _1 = move (_7.0: u32) -12:9-12:10: @6[1]: _4 = const B"> B<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span> +12:9-12:10: @6[1]: _4 = const main::B"> B<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> } else if </span><span><span class="code even" style="--layer: 1" title="13:15-13:24: @5[2]: _9 = _1 13:15-13:28: @5[3]: _8 = Gt(move _9, const 2_u32)"><span class="annotation">@5⦊</span>countdown > 2<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> if </span><span><span class="code odd" style="--layer: 1" title="14:12-14:21: @7[5]: _14 = _1 @@ -239,8 +239,8 @@ For revisions in Pull Requests (PR): 73:9-73:29: @74[21]: _92 = &(*_112) 73:9-73:29: @74[22]: _91 = &(*_92) 73:9-73:29: @74[23]: _90 = move _91 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -73:9-73:29: @74.Call: _85 = Arguments::new_v1(move _86, move _90) -> [return: bb87, unwind: bb112] -73:9-73:29: @87.Call: _84 = _print(move _85) -> [return: bb88, unwind: bb112] +73:9-73:29: @74.Call: _85 = std::fmt::Arguments::new_v1(move _86, move _90) -> [return: bb87, unwind: bb112] +73:9-73:29: @87.Call: _84 = std::io::_print(move _85) -> [return: bb88, unwind: bb112] 73:9-73:29: @88[5]: _83 = const () 74:9-74:15: @88[7]: _0 = const ()"><span class="annotation">@74,87,88⦊</span>should_be_reachable = countdown;</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="72:35-72:44: @74[1]: _82 = _62 @@ -255,8 +255,8 @@ For revisions in Pull Requests (PR): 73:9-73:29: @74[21]: _92 = &(*_112) 73:9-73:29: @74[22]: _91 = &(*_92) 73:9-73:29: @74[23]: _90 = move _91 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -73:9-73:29: @74.Call: _85 = Arguments::new_v1(move _86, move _90) -> [return: bb87, unwind: bb112] -73:9-73:29: @87.Call: _84 = _print(move _85) -> [return: bb88, unwind: bb112] +73:9-73:29: @74.Call: _85 = std::fmt::Arguments::new_v1(move _86, move _90) -> [return: bb87, unwind: bb112] +73:9-73:29: @87.Call: _84 = std::io::_print(move _85) -> [return: bb88, unwind: bb112] 73:9-73:29: @88[5]: _83 = const () 74:9-74:15: @88[7]: _0 = const ()"> println!("reached");</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="72:35-72:44: @74[1]: _82 = _62 @@ -271,8 +271,8 @@ For revisions in Pull Requests (PR): 73:9-73:29: @74[21]: _92 = &(*_112) 73:9-73:29: @74[22]: _91 = &(*_92) 73:9-73:29: @74[23]: _90 = move _91 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -73:9-73:29: @74.Call: _85 = Arguments::new_v1(move _86, move _90) -> [return: bb87, unwind: bb112] -73:9-73:29: @87.Call: _84 = _print(move _85) -> [return: bb88, unwind: bb112] +73:9-73:29: @74.Call: _85 = std::fmt::Arguments::new_v1(move _86, move _90) -> [return: bb87, unwind: bb112] +73:9-73:29: @87.Call: _84 = std::io::_print(move _85) -> [return: bb88, unwind: bb112] 73:9-73:29: @88[5]: _83 = const () 74:9-74:15: @88[7]: _0 = const ()"> return<span class="annotation">⦉@74,87,88</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> };</span></span> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html index 421fe27825c..be06ddd126d 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html @@ -69,65 +69,65 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 26"><span class="line"><span><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<div class="code" style="counter-reset: line 26"><span class="line"><span><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 33:9-33:22: @3[3]: FakeRead(ForLet, _5) 34:8-34:15: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 33:9-33:22: @3[3]: FakeRead(ForLet, _5) 34:8-34:15: @3[5]: _6 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 33:9-33:22: @3[3]: FakeRead(ForLet, _5) 34:8-34:15: @3[5]: _6 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 33:9-33:22: @3[3]: FakeRead(ForLet, _5) 34:8-34:15: @3[5]: _6 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 33:9-33:22: @3[3]: FakeRead(ForLet, _5) 34:8-34:15: @3[5]: _6 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 33:9-33:22: @3[3]: FakeRead(ForLet, _5) 34:8-34:15: @3[5]: _6 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 33:9-33:22: @3[3]: FakeRead(ForLet, _5) 34:8-34:15: @3[5]: _6 = _1"> let mut countdown = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 31:19-31:35: @1[0]: _3 = &_4 -31:19-31:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +31:19-31:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize) 31:9-31:16: @2[3]: FakeRead(ForLet, _1) 33:25-33:26: @3[2]: _5 = const 0_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html index ff3493c9f62..7f2d8d3c8ec 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html @@ -69,65 +69,65 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 14"><span class="line"><span><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<div class="code" style="counter-reset: line 14"><span class="line"><span><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 21:9-21:22: @3[3]: FakeRead(ForLet, _5) 22:8-22:15: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>fn unused_fn() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 21:9-21:22: @3[3]: FakeRead(ForLet, _5) 22:8-22:15: @3[5]: _6 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 21:9-21:22: @3[3]: FakeRead(ForLet, _5) 22:8-22:15: @3[5]: _6 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 21:9-21:22: @3[3]: FakeRead(ForLet, _5) 22:8-22:15: @3[5]: _6 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 21:9-21:22: @3[3]: FakeRead(ForLet, _5) 22:8-22:15: @3[5]: _6 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 21:9-21:22: @3[3]: FakeRead(ForLet, _5) 22:8-22:15: @3[5]: _6 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 21:9-21:22: @3[3]: FakeRead(ForLet, _5) 22:8-22:15: @3[5]: _6 = _1"> let mut countdown = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 19:19-19:35: @1[0]: _3 = &_4 -19:19-19:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +19:19-19:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize) 19:9-19:16: @2[3]: FakeRead(ForLet, _1) 21:25-21:26: @3[2]: _5 = const 0_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html index 829113e8a71..be44f71348c 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html @@ -69,65 +69,65 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>pub fn unused_pub_fn_not_in_library() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[5]: _6 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[5]: _6 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[5]: _6 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[5]: _6 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[5]: _6 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[5]: _6 = _1"> let mut countdown = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html index 3566912628a..93a4004991f 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html @@ -84,16 +84,16 @@ For revisions in Pull Requests (PR): 75:9-75:26: @3[28]: _29 = (_24.0: &&i32) 75:9-75:26: @3[30]: _30 = (_24.1: &&i32) 75:9-75:26: @3[33]: _32 = &(*_29) -75:9-75:26: @3[35]: _33 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -75:9-75:26: @3.Call: _31 = ArgumentV1::new::<&i32>(move _32, move _33) -> [return: bb5, unwind: bb14] +75:9-75:26: @3[35]: _33 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +75:9-75:26: @3.Call: _31 = std::fmt::ArgumentV1::new::<&i32>(move _32, move _33) -> [return: bb5, unwind: bb14] 75:9-75:26: @5[4]: _35 = &(*_30) -75:9-75:26: @5[6]: _36 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -75:9-75:26: @5.Call: _34 = ArgumentV1::new::<&i32>(move _35, move _36) -> [return: bb6, unwind: bb14] +75:9-75:26: @5[6]: _36 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +75:9-75:26: @5.Call: _34 = std::fmt::ArgumentV1::new::<&i32>(move _35, move _36) -> [return: bb6, unwind: bb14] 75:9-75:26: @6[2]: _23 = [move _31, move _34] 75:9-75:26: @6[7]: _22 = &_23 75:9-75:26: @6[8]: _21 = &(*_22) 75:9-75:26: @6[9]: _20 = move _21 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -75:9-75:26: @6.Call: _15 = Arguments::new_v1(move _16, move _20) -> [return: bb7, unwind: bb14] +75:9-75:26: @6.Call: _15 = std::fmt::Arguments::new_v1(move _16, move _20) -> [return: bb7, unwind: bb14] 75:9-75:26: @7.Call: core::panicking::panic_fmt(move _15) -> bb14"><span class="annotation">@3,5,6,7⦊</span>assert_eq!(1, 1);<span class="annotation">⦉@3,5,6,7</span></span><span><span class="code odd" style="--layer: 1" title="75:9-75:26: @4[0]: _2 = const ()"><span class="annotation">⦉@4</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> } else {</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="77:9-77:26: @9[0]: _37 = const ()"><span class="annotation">@9⦊</span></span></span><span class="code even" style="--layer: 2" title="77:9-77:26: @8[5]: _72 = const main::promoted[0] @@ -109,16 +109,16 @@ For revisions in Pull Requests (PR): 77:9-77:26: @8[28]: _64 = (_59.0: &&i32) 77:9-77:26: @8[30]: _65 = (_59.1: &&i32) 77:9-77:26: @8[33]: _67 = &(*_64) -77:9-77:26: @8[35]: _68 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -77:9-77:26: @8.Call: _66 = ArgumentV1::new::<&i32>(move _67, move _68) -> [return: bb10, unwind: bb14] +77:9-77:26: @8[35]: _68 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +77:9-77:26: @8.Call: _66 = std::fmt::ArgumentV1::new::<&i32>(move _67, move _68) -> [return: bb10, unwind: bb14] 77:9-77:26: @10[4]: _70 = &(*_65) -77:9-77:26: @10[6]: _71 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -77:9-77:26: @10.Call: _69 = ArgumentV1::new::<&i32>(move _70, move _71) -> [return: bb11, unwind: bb14] +77:9-77:26: @10[6]: _71 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +77:9-77:26: @10.Call: _69 = std::fmt::ArgumentV1::new::<&i32>(move _70, move _71) -> [return: bb11, unwind: bb14] 77:9-77:26: @11[2]: _58 = [move _66, move _69] 77:9-77:26: @11[7]: _57 = &_58 77:9-77:26: @11[8]: _56 = &(*_57) 77:9-77:26: @11[9]: _55 = move _56 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -77:9-77:26: @11.Call: _50 = Arguments::new_v1(move _51, move _55) -> [return: bb12, unwind: bb14] +77:9-77:26: @11.Call: _50 = std::fmt::Arguments::new_v1(move _51, move _55) -> [return: bb12, unwind: bb14] 77:9-77:26: @12.Call: core::panicking::panic_fmt(move _50) -> bb14"><span class="annotation">@8,10,11,12⦊</span>assert_eq!(1, 2);<span class="annotation">⦉@8,10,11,12</span></span><span><span class="code even" style="--layer: 1" title="77:9-77:26: @9[0]: _37 = const ()"><span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="79:2-79:2: @13.Return: return"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html index 02c25cc904c..f55bb0f32d9 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html @@ -84,16 +84,16 @@ For revisions in Pull Requests (PR): 4:14-4:30: @6[28]: _28 = (_23.0: &&i32) 4:14-4:30: @6[30]: _29 = (_23.1: &&i32) 4:14-4:30: @6[33]: _31 = &(*_28) -4:14-4:30: @6[35]: _32 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -4:14-4:30: @6.Call: _30 = ArgumentV1::new::<&i32>(move _31, move _32) -> [return: bb8, unwind: bb29] +4:14-4:30: @6[35]: _32 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +4:14-4:30: @6.Call: _30 = std::fmt::ArgumentV1::new::<&i32>(move _31, move _32) -> [return: bb8, unwind: bb29] 4:14-4:30: @8[4]: _34 = &(*_29) -4:14-4:30: @8[6]: _35 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -4:14-4:30: @8.Call: _33 = ArgumentV1::new::<&i32>(move _34, move _35) -> [return: bb9, unwind: bb29] +4:14-4:30: @8[6]: _35 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +4:14-4:30: @8.Call: _33 = std::fmt::ArgumentV1::new::<&i32>(move _34, move _35) -> [return: bb9, unwind: bb29] 4:14-4:30: @9[2]: _22 = [move _30, move _33] 4:14-4:30: @9[7]: _21 = &_22 4:14-4:30: @9[8]: _20 = &(*_21) 4:14-4:30: @9[9]: _19 = move _20 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -4:14-4:30: @9.Call: _14 = Arguments::new_v1(move _15, move _19) -> [return: bb10, unwind: bb29] +4:14-4:30: @9.Call: _14 = std::fmt::Arguments::new_v1(move _15, move _19) -> [return: bb10, unwind: bb29] 4:14-4:30: @10.Call: core::panicking::panic_fmt(move _14) -> bb29"><span class="annotation">@6,8,9,10⦊</span>assert_eq!(1, 1)<span class="annotation">⦉@6,8,9,10</span></span><span><span class="code odd" style="--layer: 1" title="4:14-4:30: @7[0]: _0 = const ()"><span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0">, // this is run,</span></span> <span class="line"><span class="code" style="--layer: 0"> 2 => </span><span><span class="code even" style="--layer: 1" title="5:14-5:30: @13[0]: _0 = const ()"><span class="annotation">@13⦊</span></span></span><span class="code even" style="--layer: 2" title="5:14-5:30: @12[5]: _141 = const fn_run_in_doctests::promoted[3] 5:14-5:30: @12[6]: _51 = &(*_141) @@ -108,16 +108,16 @@ For revisions in Pull Requests (PR): 5:14-5:30: @12[28]: _62 = (_57.0: &&i32) 5:14-5:30: @12[30]: _63 = (_57.1: &&i32) 5:14-5:30: @12[33]: _65 = &(*_62) -5:14-5:30: @12[35]: _66 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -5:14-5:30: @12.Call: _64 = ArgumentV1::new::<&i32>(move _65, move _66) -> [return: bb14, unwind: bb29] +5:14-5:30: @12[35]: _66 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +5:14-5:30: @12.Call: _64 = std::fmt::ArgumentV1::new::<&i32>(move _65, move _66) -> [return: bb14, unwind: bb29] 5:14-5:30: @14[4]: _68 = &(*_63) -5:14-5:30: @14[6]: _69 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -5:14-5:30: @14.Call: _67 = ArgumentV1::new::<&i32>(move _68, move _69) -> [return: bb15, unwind: bb29] +5:14-5:30: @14[6]: _69 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +5:14-5:30: @14.Call: _67 = std::fmt::ArgumentV1::new::<&i32>(move _68, move _69) -> [return: bb15, unwind: bb29] 5:14-5:30: @15[2]: _56 = [move _64, move _67] 5:14-5:30: @15[7]: _55 = &_56 5:14-5:30: @15[8]: _54 = &(*_55) 5:14-5:30: @15[9]: _53 = move _54 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -5:14-5:30: @15.Call: _48 = Arguments::new_v1(move _49, move _53) -> [return: bb16, unwind: bb29] +5:14-5:30: @15.Call: _48 = std::fmt::Arguments::new_v1(move _49, move _53) -> [return: bb16, unwind: bb29] 5:14-5:30: @16.Call: core::panicking::panic_fmt(move _48) -> bb29"><span class="annotation">@12,14,15,16⦊</span>assert_eq!(1, 1)<span class="annotation">⦉@12,14,15,16</span></span><span><span class="code even" style="--layer: 1" title="5:14-5:30: @13[0]: _0 = const ()"><span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0">, // this,</span></span> <span class="line"><span class="code" style="--layer: 0"> 3 => </span><span><span class="code odd" style="--layer: 1" title="6:14-6:30: @19[0]: _0 = const ()"><span class="annotation">@19⦊</span></span></span><span class="code even" style="--layer: 2" title="6:14-6:30: @18[5]: _144 = const fn_run_in_doctests::promoted[6] 6:14-6:30: @18[6]: _85 = &(*_144) @@ -132,16 +132,16 @@ For revisions in Pull Requests (PR): 6:14-6:30: @18[28]: _96 = (_91.0: &&i32) 6:14-6:30: @18[30]: _97 = (_91.1: &&i32) 6:14-6:30: @18[33]: _99 = &(*_96) -6:14-6:30: @18[35]: _100 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -6:14-6:30: @18.Call: _98 = ArgumentV1::new::<&i32>(move _99, move _100) -> [return: bb20, unwind: bb29] +6:14-6:30: @18[35]: _100 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +6:14-6:30: @18.Call: _98 = std::fmt::ArgumentV1::new::<&i32>(move _99, move _100) -> [return: bb20, unwind: bb29] 6:14-6:30: @20[4]: _102 = &(*_97) -6:14-6:30: @20[6]: _103 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -6:14-6:30: @20.Call: _101 = ArgumentV1::new::<&i32>(move _102, move _103) -> [return: bb21, unwind: bb29] +6:14-6:30: @20[6]: _103 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +6:14-6:30: @20.Call: _101 = std::fmt::ArgumentV1::new::<&i32>(move _102, move _103) -> [return: bb21, unwind: bb29] 6:14-6:30: @21[2]: _90 = [move _98, move _101] 6:14-6:30: @21[7]: _89 = &_90 6:14-6:30: @21[8]: _88 = &(*_89) 6:14-6:30: @21[9]: _87 = move _88 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -6:14-6:30: @21.Call: _82 = Arguments::new_v1(move _83, move _87) -> [return: bb22, unwind: bb29] +6:14-6:30: @21.Call: _82 = std::fmt::Arguments::new_v1(move _83, move _87) -> [return: bb22, unwind: bb29] 6:14-6:30: @22.Call: core::panicking::panic_fmt(move _82) -> bb29"><span class="annotation">@18,20,21,22⦊</span>assert_eq!(1, 1)<span class="annotation">⦉@18,20,21,22</span></span><span><span class="code odd" style="--layer: 1" title="6:14-6:30: @19[0]: _0 = const ()"><span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0">, // and this too</span></span> <span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code even" style="--layer: 1" title="7:14-7:30: @24[0]: _0 = const ()"><span class="annotation">@24⦊</span></span></span><span class="code even" style="--layer: 2" title="7:14-7:30: @23[5]: _147 = const fn_run_in_doctests::promoted[9] 7:14-7:30: @23[6]: _119 = &(*_147) @@ -156,16 +156,16 @@ For revisions in Pull Requests (PR): 7:14-7:30: @23[28]: _130 = (_125.0: &&i32) 7:14-7:30: @23[30]: _131 = (_125.1: &&i32) 7:14-7:30: @23[33]: _133 = &(*_130) -7:14-7:30: @23[35]: _134 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -7:14-7:30: @23.Call: _132 = ArgumentV1::new::<&i32>(move _133, move _134) -> [return: bb25, unwind: bb29] +7:14-7:30: @23[35]: _134 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +7:14-7:30: @23.Call: _132 = std::fmt::ArgumentV1::new::<&i32>(move _133, move _134) -> [return: bb25, unwind: bb29] 7:14-7:30: @25[4]: _136 = &(*_131) -7:14-7:30: @25[6]: _137 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -7:14-7:30: @25.Call: _135 = ArgumentV1::new::<&i32>(move _136, move _137) -> [return: bb26, unwind: bb29] +7:14-7:30: @25[6]: _137 = <&i32 as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +7:14-7:30: @25.Call: _135 = std::fmt::ArgumentV1::new::<&i32>(move _136, move _137) -> [return: bb26, unwind: bb29] 7:14-7:30: @26[2]: _124 = [move _132, move _135] 7:14-7:30: @26[7]: _123 = &_124 7:14-7:30: @26[8]: _122 = &(*_123) 7:14-7:30: @26[9]: _121 = move _122 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -7:14-7:30: @26.Call: _116 = Arguments::new_v1(move _117, move _121) -> [return: bb27, unwind: bb29] +7:14-7:30: @26.Call: _116 = std::fmt::Arguments::new_v1(move _117, move _121) -> [return: bb27, unwind: bb29] 7:14-7:30: @27.Call: core::panicking::panic_fmt(move _116) -> bb29"><span class="annotation">@23,25,26,27⦊</span>assert_eq!(1, 2)<span class="annotation">⦉@23,25,26,27</span></span><span><span class="code even" style="--layer: 1" title="7:14-7:30: @24[0]: _0 = const ()"><span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0">, // however this is not</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="9:2-9:2: @28.Return: return"><span class="annotation">@28⦊</span>‸<span class="annotation">⦉@28</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html index 3b5d1e2cdac..66a6e776a06 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html @@ -109,8 +109,8 @@ For revisions in Pull Requests (PR): 20:9-20:43: @1[18]: _15 = &(*_20) 20:9-20:43: @1[19]: _14 = &(*_15) 20:9-20:43: @1[20]: _13 = move _14 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -20:9-20:43: @1.Call: _8 = Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb11] -20:9-20:43: @3.Call: _7 = _print(move _8) -> [return: bb4, unwind: bb11] +20:9-20:43: @1.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb11] +20:9-20:43: @3.Call: _7 = std::io::_print(move _8) -> [return: bb4, unwind: bb11] 20:9-20:43: @4[5]: _6 = const () 21:16-21:22: @4[7]: _0 = std::result::Result::<(), u8>::Err(const 1_u8)"><span class="annotation">@1,3,4,8,9⦊</span>println!("Exiting with error...");</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="20:18-20:41: @1[6]: _21 = const main::promoted[1] @@ -123,8 +123,8 @@ For revisions in Pull Requests (PR): 20:9-20:43: @1[18]: _15 = &(*_20) 20:9-20:43: @1[19]: _14 = &(*_15) 20:9-20:43: @1[20]: _13 = move _14 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -20:9-20:43: @1.Call: _8 = Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb11] -20:9-20:43: @3.Call: _7 = _print(move _8) -> [return: bb4, unwind: bb11] +20:9-20:43: @1.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb11] +20:9-20:43: @3.Call: _7 = std::io::_print(move _8) -> [return: bb4, unwind: bb11] 20:9-20:43: @4[5]: _6 = const () 21:16-21:22: @4[7]: _0 = std::result::Result::<(), u8>::Err(const 1_u8)"> return Err(1)<span class="annotation">⦉@1,3,4,8,9</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="22:6-22:6: @2[0]: _3 = const () diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html index b5dedeec8ac..57d56c5cf73 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html @@ -69,7 +69,7 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 8"><span class="line"> <span><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const <Firework as Drop>::drop::promoted[0] +<div class="code" style="counter-reset: line 8"><span class="line"> <span><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const <Firework as std::ops::Drop>::drop::promoted[0] 10:18-10:36: @0[7]: _7 = &(*_19) 10:18-10:36: @0[8]: _6 = &(*_7) 10:18-10:36: @0[9]: _5 = move _6 as &[&str] (Pointer(Unsize)) @@ -79,17 +79,17 @@ For revisions in Pull Requests (PR): 10:9-10:53: @0[22]: _15 = (_13.0: &i32) 10:9-10:53: @0[25]: _17 = &(*_15) 10:9-10:53: @0[27]: _18 = <i32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -10:9-10:53: @0.Call: _16 = ArgumentV1::new::<i32>(move _17, move _18) -> [return: bb1, unwind: bb4] +10:9-10:53: @0.Call: _16 = std::fmt::ArgumentV1::new::<i32>(move _17, move _18) -> [return: bb1, unwind: bb4] 10:9-10:53: @1[2]: _12 = [move _16] 10:9-10:53: @1[5]: _11 = &_12 10:9-10:53: @1[6]: _10 = &(*_11) 10:9-10:53: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -10:9-10:53: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +10:9-10:53: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +10:9-10:53: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 10:9-10:53: @3[6]: _2 = const () 9:24-11:6: @3[8]: _0 = const () 11:6-11:6: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>fn drop(&mut self) {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const <Firework as Drop>::drop::promoted[0] +<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const <Firework as std::ops::Drop>::drop::promoted[0] 10:18-10:36: @0[7]: _7 = &(*_19) 10:18-10:36: @0[8]: _6 = &(*_7) 10:18-10:36: @0[9]: _5 = move _6 as &[&str] (Pointer(Unsize)) @@ -99,17 +99,17 @@ For revisions in Pull Requests (PR): 10:9-10:53: @0[22]: _15 = (_13.0: &i32) 10:9-10:53: @0[25]: _17 = &(*_15) 10:9-10:53: @0[27]: _18 = <i32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -10:9-10:53: @0.Call: _16 = ArgumentV1::new::<i32>(move _17, move _18) -> [return: bb1, unwind: bb4] +10:9-10:53: @0.Call: _16 = std::fmt::ArgumentV1::new::<i32>(move _17, move _18) -> [return: bb1, unwind: bb4] 10:9-10:53: @1[2]: _12 = [move _16] 10:9-10:53: @1[5]: _11 = &_12 10:9-10:53: @1[6]: _10 = &(*_11) 10:9-10:53: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -10:9-10:53: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +10:9-10:53: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +10:9-10:53: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 10:9-10:53: @3[6]: _2 = const () 9:24-11:6: @3[8]: _0 = const () 11:6-11:6: @3.Return: return"> println!("BOOM times {}!!!", self.strength);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const <Firework as Drop>::drop::promoted[0] +<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const <Firework as std::ops::Drop>::drop::promoted[0] 10:18-10:36: @0[7]: _7 = &(*_19) 10:18-10:36: @0[8]: _6 = &(*_7) 10:18-10:36: @0[9]: _5 = move _6 as &[&str] (Pointer(Unsize)) @@ -119,13 +119,13 @@ For revisions in Pull Requests (PR): 10:9-10:53: @0[22]: _15 = (_13.0: &i32) 10:9-10:53: @0[25]: _17 = &(*_15) 10:9-10:53: @0[27]: _18 = <i32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -10:9-10:53: @0.Call: _16 = ArgumentV1::new::<i32>(move _17, move _18) -> [return: bb1, unwind: bb4] +10:9-10:53: @0.Call: _16 = std::fmt::ArgumentV1::new::<i32>(move _17, move _18) -> [return: bb1, unwind: bb4] 10:9-10:53: @1[2]: _12 = [move _16] 10:9-10:53: @1[5]: _11 = &_12 10:9-10:53: @1[6]: _10 = &(*_11) 10:9-10:53: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -10:9-10:53: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +10:9-10:53: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +10:9-10:53: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 10:9-10:53: @3[6]: _2 = const () 9:24-11:6: @3[8]: _0 = const () 11:6-11:6: @3.Return: return"> }<span class="annotation">⦉@0,1,2,3</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html index 0373b38e1b1..098c1404251 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html @@ -178,8 +178,8 @@ For revisions in Pull Requests (PR): 31:9-31:43: @4[18]: _21 = &(*_26) 31:9-31:43: @4[19]: _20 = &(*_21) 31:9-31:43: @4[20]: _19 = move _20 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -31:9-31:43: @4.Call: _14 = Arguments::new_v1(move _15, move _19) -> [return: bb6, unwind: bb14] -31:9-31:43: @6.Call: _13 = _print(move _14) -> [return: bb7, unwind: bb14] +31:9-31:43: @4.Call: _14 = std::fmt::Arguments::new_v1(move _15, move _19) -> [return: bb6, unwind: bb14] +31:9-31:43: @6.Call: _13 = std::io::_print(move _14) -> [return: bb7, unwind: bb14] 31:9-31:43: @7[5]: _12 = const () 32:16-32:22: @7[7]: _0 = std::result::Result::<(), u8>::Err(const 1_u8)"><span class="annotation">@4,6,7,11,12⦊</span>println!("Exiting with error...");</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="31:18-31:41: @4[6]: _27 = const main::promoted[1] @@ -192,8 +192,8 @@ For revisions in Pull Requests (PR): 31:9-31:43: @4[18]: _21 = &(*_26) 31:9-31:43: @4[19]: _20 = &(*_21) 31:9-31:43: @4[20]: _19 = move _20 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -31:9-31:43: @4.Call: _14 = Arguments::new_v1(move _15, move _19) -> [return: bb6, unwind: bb14] -31:9-31:43: @6.Call: _13 = _print(move _14) -> [return: bb7, unwind: bb14] +31:9-31:43: @4.Call: _14 = std::fmt::Arguments::new_v1(move _15, move _19) -> [return: bb6, unwind: bb14] +31:9-31:43: @6.Call: _13 = std::io::_print(move _14) -> [return: bb7, unwind: bb14] 31:9-31:43: @7[5]: _12 = const () 32:16-32:22: @7[7]: _0 = std::result::Result::<(), u8>::Err(const 1_u8)"> return Err(1)<span class="annotation">⦉@4,6,7,11,12</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const () diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html index c4e99bd679d..4908bc7b4a7 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html @@ -69,7 +69,7 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 16"><span class="line"> <span><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const <Firework<T> as Drop>::drop::promoted[0] +<div class="code" style="counter-reset: line 16"><span class="line"> <span><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const <Firework<T> as std::ops::Drop>::drop::promoted[0] 18:18-18:36: @0[7]: _7 = &(*_19) 18:18-18:36: @0[8]: _6 = &(*_7) 18:18-18:36: @0[9]: _5 = move _6 as &[&str] (Pointer(Unsize)) @@ -79,17 +79,17 @@ For revisions in Pull Requests (PR): 18:9-18:53: @0[22]: _15 = (_13.0: &T) 18:9-18:53: @0[25]: _17 = &(*_15) 18:9-18:53: @0[27]: _18 = <T as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -18:9-18:53: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb4] +18:9-18:53: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb4] 18:9-18:53: @1[2]: _12 = [move _16] 18:9-18:53: @1[5]: _11 = &_12 18:9-18:53: @1[6]: _10 = &(*_11) 18:9-18:53: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -18:9-18:53: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +18:9-18:53: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +18:9-18:53: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 18:9-18:53: @3[6]: _2 = const () 17:24-19:6: @3[8]: _0 = const () 19:6-19:6: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>fn drop(&mut self) {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const <Firework<T> as Drop>::drop::promoted[0] +<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const <Firework<T> as std::ops::Drop>::drop::promoted[0] 18:18-18:36: @0[7]: _7 = &(*_19) 18:18-18:36: @0[8]: _6 = &(*_7) 18:18-18:36: @0[9]: _5 = move _6 as &[&str] (Pointer(Unsize)) @@ -99,17 +99,17 @@ For revisions in Pull Requests (PR): 18:9-18:53: @0[22]: _15 = (_13.0: &T) 18:9-18:53: @0[25]: _17 = &(*_15) 18:9-18:53: @0[27]: _18 = <T as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -18:9-18:53: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb4] +18:9-18:53: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb4] 18:9-18:53: @1[2]: _12 = [move _16] 18:9-18:53: @1[5]: _11 = &_12 18:9-18:53: @1[6]: _10 = &(*_11) 18:9-18:53: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -18:9-18:53: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +18:9-18:53: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +18:9-18:53: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 18:9-18:53: @3[6]: _2 = const () 17:24-19:6: @3[8]: _0 = const () 19:6-19:6: @3.Return: return"> println!("BOOM times {}!!!", self.strength);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const <Firework<T> as Drop>::drop::promoted[0] +<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const <Firework<T> as std::ops::Drop>::drop::promoted[0] 18:18-18:36: @0[7]: _7 = &(*_19) 18:18-18:36: @0[8]: _6 = &(*_7) 18:18-18:36: @0[9]: _5 = move _6 as &[&str] (Pointer(Unsize)) @@ -119,13 +119,13 @@ For revisions in Pull Requests (PR): 18:9-18:53: @0[22]: _15 = (_13.0: &T) 18:9-18:53: @0[25]: _17 = &(*_15) 18:9-18:53: @0[27]: _18 = <T as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -18:9-18:53: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb4] +18:9-18:53: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb4] 18:9-18:53: @1[2]: _12 = [move _16] 18:9-18:53: @1[5]: _11 = &_12 18:9-18:53: @1[6]: _10 = &(*_11) 18:9-18:53: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -18:9-18:53: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +18:9-18:53: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +18:9-18:53: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 18:9-18:53: @3[6]: _2 = const () 17:24-19:6: @3[8]: _0 = const () 19:6-19:6: @3.Return: return"> }<span class="annotation">⦉@0,1,2,3</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html index dd9ba4a190c..d6eccf57846 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html @@ -69,153 +69,153 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> let</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> is_true</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> =</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> std::env::args().len()</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> ==</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> 1</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> ;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> let</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> mut</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> countdown</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> =</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> 0</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> ;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 15:9-16:14: @3[3]: FakeRead(ForLet, _5) 21:9-21:16: @3[5]: _6 = _1"> if</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 10:9-10:25: @1[0]: _3 = &_4 -10:9-10:31: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +10:9-10:31: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize) 8:5-8:12: @2[3]: FakeRead(ForLet, _1) 18:9-18:10: @3[2]: _5 = const 0_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html index b642be382cb..e0f0ac40205 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html @@ -69,73 +69,73 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"> let mut countdown = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 11:9-11:16: @3[6]: _7 = _1"> if</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb11] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb11] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb10] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html index 29548fa1124..1dc5bb64e0b 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html @@ -69,24 +69,24 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 32"><span class="line"> <span><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -> [return: bb1, unwind: bb3] +<div class="code" style="counter-reset: line 32"><span class="line"> <span><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = main::in_func(const main::IN_CONST) -> [return: bb1, unwind: bb3] 35:13-35:17: @1[3]: _4 = &mut (*_1) -35:13-35:38: @1.Call: _3 = <Self as InTrait>::trait_func(move _4, const IN_CONST) -> [return: bb2, unwind: bb3] +35:13-35:38: @1.Call: _3 = <Self as main::InTrait>::trait_func(move _4, const main::IN_CONST) -> [return: bb2, unwind: bb3] 33:42-36:10: @2[2]: _0 = const () 36:10-36:10: @2.Return: return"><span class="annotation">@0,1,2⦊</span>fn default_trait_func(&mut self) {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -> [return: bb1, unwind: bb3] +<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = main::in_func(const main::IN_CONST) -> [return: bb1, unwind: bb3] 35:13-35:17: @1[3]: _4 = &mut (*_1) -35:13-35:38: @1.Call: _3 = <Self as InTrait>::trait_func(move _4, const IN_CONST) -> [return: bb2, unwind: bb3] +35:13-35:38: @1.Call: _3 = <Self as main::InTrait>::trait_func(move _4, const main::IN_CONST) -> [return: bb2, unwind: bb3] 33:42-36:10: @2[2]: _0 = const () 36:10-36:10: @2.Return: return"> in_func(IN_CONST);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -> [return: bb1, unwind: bb3] +<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = main::in_func(const main::IN_CONST) -> [return: bb1, unwind: bb3] 35:13-35:17: @1[3]: _4 = &mut (*_1) -35:13-35:38: @1.Call: _3 = <Self as InTrait>::trait_func(move _4, const IN_CONST) -> [return: bb2, unwind: bb3] +35:13-35:38: @1.Call: _3 = <Self as main::InTrait>::trait_func(move _4, const main::IN_CONST) -> [return: bb2, unwind: bb3] 33:42-36:10: @2[2]: _0 = const () 36:10-36:10: @2.Return: return"> self.trait_func(IN_CONST);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -> [return: bb1, unwind: bb3] +<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = main::in_func(const main::IN_CONST) -> [return: bb1, unwind: bb3] 35:13-35:17: @1[3]: _4 = &mut (*_1) -35:13-35:38: @1.Call: _3 = <Self as InTrait>::trait_func(move _4, const IN_CONST) -> [return: bb2, unwind: bb3] +35:13-35:38: @1.Call: _3 = <Self as main::InTrait>::trait_func(move _4, const main::IN_CONST) -> [return: bb2, unwind: bb3] 33:42-36:10: @2[2]: _0 = const () 36:10-36:10: @2.Return: return"> }<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html index 8b5257b02bb..82724e5e865 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html @@ -76,7 +76,7 @@ For revisions in Pull Requests (PR): 20:17-20:22: @0[8]: _6 = CheckedAdd(_4, _5) 20:17-20:22: @1[0]: _3 = move (_6.0: u32) 20:13-20:14: @1[3]: FakeRead(ForLet, _3) -21:18-21:26: @1[9]: _23 = const in_func::promoted[0] +21:18-21:26: @1[9]: _23 = const main::in_func::promoted[0] 21:18-21:26: @1[10]: _11 = &(*_23) 21:18-21:26: @1[11]: _10 = &(*_11) 21:18-21:26: @1[12]: _9 = move _10 as &[&str] (Pointer(Unsize)) @@ -86,13 +86,13 @@ For revisions in Pull Requests (PR): 21:9-21:30: @1[25]: _19 = (_17.0: &u32) 21:9-21:30: @1[28]: _21 = &(*_19) 21:9-21:30: @1[30]: _22 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -21:9-21:30: @1.Call: _20 = ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] +21:9-21:30: @1.Call: _20 = std::fmt::ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] 21:9-21:30: @2[2]: _16 = [move _20] 21:9-21:30: @2[5]: _15 = &_16 21:9-21:30: @2[6]: _14 = &(*_15) 21:9-21:30: @2[7]: _13 = move _14 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] -21:9-21:30: @3.Call: _7 = _print(move _8) -> [return: bb4, unwind: bb5] +21:9-21:30: @2.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] +21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -> [return: bb4, unwind: bb5] 21:9-21:30: @4[6]: _0 = const () 22:6-22:6: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>fn in_func(a: u32) {</span></span> <span class="line"><span class="code even" style="--layer: 1" title="19:17-19:18: @0[1]: _2 = const 1_u32 @@ -102,7 +102,7 @@ For revisions in Pull Requests (PR): 20:17-20:22: @0[8]: _6 = CheckedAdd(_4, _5) 20:17-20:22: @1[0]: _3 = move (_6.0: u32) 20:13-20:14: @1[3]: FakeRead(ForLet, _3) -21:18-21:26: @1[9]: _23 = const in_func::promoted[0] +21:18-21:26: @1[9]: _23 = const main::in_func::promoted[0] 21:18-21:26: @1[10]: _11 = &(*_23) 21:18-21:26: @1[11]: _10 = &(*_11) 21:18-21:26: @1[12]: _9 = move _10 as &[&str] (Pointer(Unsize)) @@ -112,13 +112,13 @@ For revisions in Pull Requests (PR): 21:9-21:30: @1[25]: _19 = (_17.0: &u32) 21:9-21:30: @1[28]: _21 = &(*_19) 21:9-21:30: @1[30]: _22 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -21:9-21:30: @1.Call: _20 = ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] +21:9-21:30: @1.Call: _20 = std::fmt::ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] 21:9-21:30: @2[2]: _16 = [move _20] 21:9-21:30: @2[5]: _15 = &_16 21:9-21:30: @2[6]: _14 = &(*_15) 21:9-21:30: @2[7]: _13 = move _14 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] -21:9-21:30: @3.Call: _7 = _print(move _8) -> [return: bb4, unwind: bb5] +21:9-21:30: @2.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] +21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -> [return: bb4, unwind: bb5] 21:9-21:30: @4[6]: _0 = const () 22:6-22:6: @4.Return: return"> let b = 1;</span></span> <span class="line"><span class="code even" style="--layer: 1" title="19:17-19:18: @0[1]: _2 = const 1_u32 @@ -128,7 +128,7 @@ For revisions in Pull Requests (PR): 20:17-20:22: @0[8]: _6 = CheckedAdd(_4, _5) 20:17-20:22: @1[0]: _3 = move (_6.0: u32) 20:13-20:14: @1[3]: FakeRead(ForLet, _3) -21:18-21:26: @1[9]: _23 = const in_func::promoted[0] +21:18-21:26: @1[9]: _23 = const main::in_func::promoted[0] 21:18-21:26: @1[10]: _11 = &(*_23) 21:18-21:26: @1[11]: _10 = &(*_11) 21:18-21:26: @1[12]: _9 = move _10 as &[&str] (Pointer(Unsize)) @@ -138,13 +138,13 @@ For revisions in Pull Requests (PR): 21:9-21:30: @1[25]: _19 = (_17.0: &u32) 21:9-21:30: @1[28]: _21 = &(*_19) 21:9-21:30: @1[30]: _22 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -21:9-21:30: @1.Call: _20 = ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] +21:9-21:30: @1.Call: _20 = std::fmt::ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] 21:9-21:30: @2[2]: _16 = [move _20] 21:9-21:30: @2[5]: _15 = &_16 21:9-21:30: @2[6]: _14 = &(*_15) 21:9-21:30: @2[7]: _13 = move _14 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] -21:9-21:30: @3.Call: _7 = _print(move _8) -> [return: bb4, unwind: bb5] +21:9-21:30: @2.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] +21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -> [return: bb4, unwind: bb5] 21:9-21:30: @4[6]: _0 = const () 22:6-22:6: @4.Return: return"> let c = a + b;</span></span> <span class="line"><span class="code even" style="--layer: 1" title="19:17-19:18: @0[1]: _2 = const 1_u32 @@ -154,7 +154,7 @@ For revisions in Pull Requests (PR): 20:17-20:22: @0[8]: _6 = CheckedAdd(_4, _5) 20:17-20:22: @1[0]: _3 = move (_6.0: u32) 20:13-20:14: @1[3]: FakeRead(ForLet, _3) -21:18-21:26: @1[9]: _23 = const in_func::promoted[0] +21:18-21:26: @1[9]: _23 = const main::in_func::promoted[0] 21:18-21:26: @1[10]: _11 = &(*_23) 21:18-21:26: @1[11]: _10 = &(*_11) 21:18-21:26: @1[12]: _9 = move _10 as &[&str] (Pointer(Unsize)) @@ -164,13 +164,13 @@ For revisions in Pull Requests (PR): 21:9-21:30: @1[25]: _19 = (_17.0: &u32) 21:9-21:30: @1[28]: _21 = &(*_19) 21:9-21:30: @1[30]: _22 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -21:9-21:30: @1.Call: _20 = ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] +21:9-21:30: @1.Call: _20 = std::fmt::ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] 21:9-21:30: @2[2]: _16 = [move _20] 21:9-21:30: @2[5]: _15 = &_16 21:9-21:30: @2[6]: _14 = &(*_15) 21:9-21:30: @2[7]: _13 = move _14 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] -21:9-21:30: @3.Call: _7 = _print(move _8) -> [return: bb4, unwind: bb5] +21:9-21:30: @2.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] +21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -> [return: bb4, unwind: bb5] 21:9-21:30: @4[6]: _0 = const () 22:6-22:6: @4.Return: return"> println!("c = {}", c)</span></span> <span class="line"><span class="code even" style="--layer: 1" title="19:17-19:18: @0[1]: _2 = const 1_u32 @@ -180,7 +180,7 @@ For revisions in Pull Requests (PR): 20:17-20:22: @0[8]: _6 = CheckedAdd(_4, _5) 20:17-20:22: @1[0]: _3 = move (_6.0: u32) 20:13-20:14: @1[3]: FakeRead(ForLet, _3) -21:18-21:26: @1[9]: _23 = const in_func::promoted[0] +21:18-21:26: @1[9]: _23 = const main::in_func::promoted[0] 21:18-21:26: @1[10]: _11 = &(*_23) 21:18-21:26: @1[11]: _10 = &(*_11) 21:18-21:26: @1[12]: _9 = move _10 as &[&str] (Pointer(Unsize)) @@ -190,13 +190,13 @@ For revisions in Pull Requests (PR): 21:9-21:30: @1[25]: _19 = (_17.0: &u32) 21:9-21:30: @1[28]: _21 = &(*_19) 21:9-21:30: @1[30]: _22 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -21:9-21:30: @1.Call: _20 = ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] +21:9-21:30: @1.Call: _20 = std::fmt::ArgumentV1::new::<u32>(move _21, move _22) -> [return: bb2, unwind: bb5] 21:9-21:30: @2[2]: _16 = [move _20] 21:9-21:30: @2[5]: _15 = &_16 21:9-21:30: @2[6]: _14 = &(*_15) 21:9-21:30: @2[7]: _13 = move _14 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] -21:9-21:30: @3.Call: _7 = _print(move _8) -> [return: bb4, unwind: bb5] +21:9-21:30: @2.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -> [return: bb3, unwind: bb5] +21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -> [return: bb4, unwind: bb5] 21:9-21:30: @4[6]: _0 = const () 22:6-22:6: @4.Return: return"> }<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html index ee1e0339049..b00a781a0a7 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html @@ -73,28 +73,28 @@ For revisions in Pull Requests (PR): 41:13-41:41: @0[2]: _4 = CheckedAdd(((*_1).0: u32), _3) 41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32) 42:21-42:41: @1[4]: _6 = ((*_1).0: u32) -42:13-42:42: @1.Call: _5 = in_func(move _6) -> [return: bb2, unwind: bb3] +42:13-42:42: @1.Call: _5 = main::in_func(move _6) -> [return: bb2, unwind: bb3] 40:45-43:10: @2[2]: _0 = const () 43:10-43:10: @2.Return: return"><span class="annotation">@0,1,2⦊</span>fn trait_func(&mut self, incr: u32) {</span></span> <span class="line"><span class="code even" style="--layer: 1" title="41:37-41:41: @0[1]: _3 = _2 41:13-41:41: @0[2]: _4 = CheckedAdd(((*_1).0: u32), _3) 41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32) 42:21-42:41: @1[4]: _6 = ((*_1).0: u32) -42:13-42:42: @1.Call: _5 = in_func(move _6) -> [return: bb2, unwind: bb3] +42:13-42:42: @1.Call: _5 = main::in_func(move _6) -> [return: bb2, unwind: bb3] 40:45-43:10: @2[2]: _0 = const () 43:10-43:10: @2.Return: return"> self.in_struct_field += incr;</span></span> <span class="line"><span class="code even" style="--layer: 1" title="41:37-41:41: @0[1]: _3 = _2 41:13-41:41: @0[2]: _4 = CheckedAdd(((*_1).0: u32), _3) 41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32) 42:21-42:41: @1[4]: _6 = ((*_1).0: u32) -42:13-42:42: @1.Call: _5 = in_func(move _6) -> [return: bb2, unwind: bb3] +42:13-42:42: @1.Call: _5 = main::in_func(move _6) -> [return: bb2, unwind: bb3] 40:45-43:10: @2[2]: _0 = const () 43:10-43:10: @2.Return: return"> in_func(self.in_struct_field);</span></span> <span class="line"><span class="code even" style="--layer: 1" title="41:37-41:41: @0[1]: _3 = _2 41:13-41:41: @0[2]: _4 = CheckedAdd(((*_1).0: u32), _3) 41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32) 42:21-42:41: @1[4]: _6 = ((*_1).0: u32) -42:13-42:42: @1.Call: _5 = in_func(move _6) -> [return: bb2, unwind: bb3] +42:13-42:42: @1.Call: _5 = main::in_func(move _6) -> [return: bb2, unwind: bb3] 40:45-43:10: @2[2]: _0 = const () 43:10-43:10: @2.Return: return"> }<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html index d21710b7240..4a1003dfbed 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html @@ -73,33 +73,33 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> <span class="line"><span class="code" style="--layer: 0"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> <span class="line"><span class="code" style="--layer: 0"> // dependent conditions.</span></span> -<span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_u32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"><span class="annotation">@0,1,2,3⦊</span>is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_u32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_u32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"> let mut countdown = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_u32 @@ -146,44 +146,44 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> type InType = String;</span></span> <span class="line"><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> if </span><span><span class="code odd" style="--layer: 1" title="48:8-48:15: @6[4]: _9 = _1"><span class="annotation">@6⦊</span>is_true<span class="annotation">⦉@6</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="49:17-49:26: @7[2]: _11 = _5 -49:9-49:27: @7.Call: _10 = in_func(move _11) -> [return: bb9, unwind: bb13] +49:9-49:27: @7.Call: _10 = main::in_func(move _11) -> [return: bb9, unwind: bb13] 48:16-50:6: @9[2]: _8 = const ()"><span class="annotation">@7,9⦊</span>{</span></span> <span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @7[2]: _11 = _5 -49:9-49:27: @7.Call: _10 = in_func(move _11) -> [return: bb9, unwind: bb13] +49:9-49:27: @7.Call: _10 = main::in_func(move _11) -> [return: bb9, unwind: bb13] 48:16-50:6: @9[2]: _8 = const ()"> in_func(countdown);</span></span> <span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @7[2]: _11 = _5 -49:9-49:27: @7.Call: _10 = in_func(move _11) -> [return: bb9, unwind: bb13] +49:9-49:27: @7.Call: _10 = main::in_func(move _11) -> [return: bb9, unwind: bb13] 48:16-50:6: @9[2]: _8 = const ()"> }<span class="annotation">⦉@7,9</span></span></span><span><span class="code odd" style="--layer: 1" title="50:6-50:6: @8[0]: _8 = const ()"><span class="annotation">@8⦊</span>‸<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"></span></span> -<span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = InStruct { in_struct_field: const 101_u32 } +<span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 } 52:9-52:16: @10[4]: FakeRead(ForLet, _12) 56:5-56:8: @10[7]: _14 = &mut _12 -56:5-56:29: @10.Call: _13 = <InStruct as InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] +56:5-56:29: @10.Call: _13 = <main::InStruct as main::InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] 57:2-57:2: @11.Return: return"><span class="annotation">@10,11⦊</span>mut val = InStruct {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = InStruct { in_struct_field: const 101_u32 } +<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 } 52:9-52:16: @10[4]: FakeRead(ForLet, _12) 56:5-56:8: @10[7]: _14 = &mut _12 -56:5-56:29: @10.Call: _13 = <InStruct as InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] +56:5-56:29: @10.Call: _13 = <main::InStruct as main::InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] 57:2-57:2: @11.Return: return"> in_struct_field: 101,</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = InStruct { in_struct_field: const 101_u32 } +<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 } 52:9-52:16: @10[4]: FakeRead(ForLet, _12) 56:5-56:8: @10[7]: _14 = &mut _12 -56:5-56:29: @10.Call: _13 = <InStruct as InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] +56:5-56:29: @10.Call: _13 = <main::InStruct as main::InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] 57:2-57:2: @11.Return: return"> };</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = InStruct { in_struct_field: const 101_u32 } +<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 } 52:9-52:16: @10[4]: FakeRead(ForLet, _12) 56:5-56:8: @10[7]: _14 = &mut _12 -56:5-56:29: @10.Call: _13 = <InStruct as InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] +56:5-56:29: @10.Call: _13 = <main::InStruct as main::InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] 57:2-57:2: @11.Return: return"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = InStruct { in_struct_field: const 101_u32 } +<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 } 52:9-52:16: @10[4]: FakeRead(ForLet, _12) 56:5-56:8: @10[7]: _14 = &mut _12 -56:5-56:29: @10.Call: _13 = <InStruct as InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] +56:5-56:29: @10.Call: _13 = <main::InStruct as main::InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] 57:2-57:2: @11.Return: return"> val.default_trait_func();</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = InStruct { in_struct_field: const 101_u32 } +<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 } 52:9-52:16: @10[4]: FakeRead(ForLet, _12) 56:5-56:8: @10[7]: _14 = &mut _12 -56:5-56:29: @10.Call: _13 = <InStruct as InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] +56:5-56:29: @10.Call: _13 = <main::InStruct as main::InTrait>::default_trait_func(move _14) -> [return: bb11, unwind: bb13] 57:2-57:2: @11.Return: return">}<span class="annotation">⦉@10,11</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html index 0cfe2119fbc..358e2e2bbba 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html @@ -69,9 +69,9 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) @@ -79,9 +79,9 @@ For revisions in Pull Requests (PR): 9:17-9:22: @3[6]: _6 = (_8.1: i32) 9:24-9:29: @3[8]: _7 = (_8.2: i32) 10:8-10:15: @3[12]: _10 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) @@ -89,9 +89,9 @@ For revisions in Pull Requests (PR): 9:17-9:22: @3[6]: _6 = (_8.1: i32) 9:24-9:29: @3[8]: _7 = (_8.2: i32) 10:8-10:15: @3[12]: _10 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) @@ -99,9 +99,9 @@ For revisions in Pull Requests (PR): 9:17-9:22: @3[6]: _6 = (_8.1: i32) 9:24-9:29: @3[8]: _7 = (_8.2: i32) 10:8-10:15: @3[12]: _10 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) @@ -109,9 +109,9 @@ For revisions in Pull Requests (PR): 9:17-9:22: @3[6]: _6 = (_8.1: i32) 9:24-9:29: @3[8]: _7 = (_8.2: i32) 10:8-10:15: @3[12]: _10 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) @@ -119,9 +119,9 @@ For revisions in Pull Requests (PR): 9:17-9:22: @3[6]: _6 = (_8.1: i32) 9:24-9:29: @3[8]: _7 = (_8.2: i32) 10:8-10:15: @3[12]: _10 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) @@ -129,9 +129,9 @@ For revisions in Pull Requests (PR): 9:17-9:22: @3[6]: _6 = (_8.1: i32) 9:24-9:29: @3[8]: _7 = (_8.2: i32) 10:8-10:15: @3[12]: _10 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) @@ -139,9 +139,9 @@ For revisions in Pull Requests (PR): 9:17-9:22: @3[6]: _6 = (_8.1: i32) 9:24-9:29: @3[8]: _7 = (_8.2: i32) 10:8-10:15: @3[12]: _10 = _1"> let (mut a, mut b, mut c) = (0, 0, 0);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb36] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb36] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb35] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32) diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html index 54b1ea45cba..95e8f0b71ea 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html @@ -80,14 +80,14 @@ For revisions in Pull Requests (PR): 24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13) 24:5-24:34: @0[25]: _15 = (_13.0: &DebugTest) 24:5-24:34: @0[28]: _17 = &(*_15) -24:5-24:34: @0[30]: _18 = <DebugTest as Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -24:5-24:34: @0.Call: _16 = ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] +24:5-24:34: @0[30]: _18 = <DebugTest as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] 24:5-24:34: @1[2]: _12 = [move _16] 24:5-24:34: @1[5]: _11 = &_12 24:5-24:34: @1[6]: _10 = &(*_11) 24:5-24:34: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -24:5-24:34: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 24:5-24:34: @3[6]: _2 = const () 22:11-25:2: @3[8]: _0 = const () 25:2-25:2: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> @@ -102,14 +102,14 @@ For revisions in Pull Requests (PR): 24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13) 24:5-24:34: @0[25]: _15 = (_13.0: &DebugTest) 24:5-24:34: @0[28]: _17 = &(*_15) -24:5-24:34: @0[30]: _18 = <DebugTest as Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -24:5-24:34: @0.Call: _16 = ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] +24:5-24:34: @0[30]: _18 = <DebugTest as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] 24:5-24:34: @1[2]: _12 = [move _16] 24:5-24:34: @1[5]: _11 = &_12 24:5-24:34: @1[6]: _10 = &(*_11) 24:5-24:34: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -24:5-24:34: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 24:5-24:34: @3[6]: _2 = const () 22:11-25:2: @3[8]: _0 = const () 25:2-25:2: @3.Return: return"> let debug_test = DebugTest;</span></span> @@ -124,14 +124,14 @@ For revisions in Pull Requests (PR): 24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13) 24:5-24:34: @0[25]: _15 = (_13.0: &DebugTest) 24:5-24:34: @0[28]: _17 = &(*_15) -24:5-24:34: @0[30]: _18 = <DebugTest as Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -24:5-24:34: @0.Call: _16 = ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] +24:5-24:34: @0[30]: _18 = <DebugTest as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] 24:5-24:34: @1[2]: _12 = [move _16] 24:5-24:34: @1[5]: _11 = &_12 24:5-24:34: @1[6]: _10 = &(*_11) 24:5-24:34: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -24:5-24:34: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 24:5-24:34: @3[6]: _2 = const () 22:11-25:2: @3[8]: _0 = const () 25:2-25:2: @3.Return: return"> println!("{:?}", debug_test);</span></span> @@ -146,14 +146,14 @@ For revisions in Pull Requests (PR): 24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13) 24:5-24:34: @0[25]: _15 = (_13.0: &DebugTest) 24:5-24:34: @0[28]: _17 = &(*_15) -24:5-24:34: @0[30]: _18 = <DebugTest as Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -24:5-24:34: @0.Call: _16 = ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] +24:5-24:34: @0[30]: _18 = <DebugTest as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r DebugTest, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::<DebugTest>(move _17, move _18) -> [return: bb1, unwind: bb4] 24:5-24:34: @1[2]: _12 = [move _16] 24:5-24:34: @1[5]: _11 = &_12 24:5-24:34: @1[6]: _10 = &(*_11) 24:5-24:34: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] -24:5-24:34: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb4] +24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb4] +24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb4] 24:5-24:34: @3[6]: _2 = const () 22:11-25:2: @3[8]: _0 = const () 25:2-25:2: @3.Return: return">}<span class="annotation">⦉@0,1,2,3</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html index b3f344f7fc0..f6f08b6a770 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html @@ -77,20 +77,20 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code odd" style="--layer: 1" title="12:28-13:18: @8[0]: _7 = const ()"> }<span class="annotation">⦉@6,8</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> }</span><span><span class="code even" style="--layer: 1" title="14:14-14:14: @3[0]: _5 = const ()"><span class="annotation">@3⦊</span>‸<span class="annotation">⦉@3</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="15:20-15:21: @9[6]: _13 = &mut (*_2) -15:23-15:30: @9[11]: _32 = const <DebugTest as Debug>::fmt::promoted[1] +15:23-15:30: @9[11]: _32 = const <DebugTest as std::fmt::Debug>::fmt::promoted[1] 15:23-15:30: @9[12]: _17 = &(*_32) 15:23-15:30: @9[13]: _16 = &(*_17) 15:23-15:30: @9[14]: _15 = move _16 as &[&str] (Pointer(Unsize)) 15:13-15:31: @9[20]: _23 = () 15:13-15:31: @9[21]: FakeRead(ForMatchedPlace, _23) -15:13-15:31: @9[22]: _31 = const <DebugTest as Debug>::fmt::promoted[0] +15:13-15:31: @9[22]: _31 = const <DebugTest as std::fmt::Debug>::fmt::promoted[0] 15:13-15:31: @9[23]: _21 = &(*_31) 15:13-15:31: @9[24]: _20 = &(*_21) 15:13-15:31: @9[25]: _19 = move _20 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -15:13-15:31: @9.Call: _14 = Arguments::new_v1(move _15, move _19) -> [return: bb10, unwind: bb21] -15:13-15:31: @10.Call: _12 = Formatter::write_fmt(move _13, move _14) -> [return: bb11, unwind: bb21]"><span class="annotation">@9,10,11,12⦊</span>write!(f, "error")<span class="annotation">⦉@9,10,11,12</span></span></span><span><span class="code even" style="--layer: 1" title="15:31-15:32: @16[1]: _25 = ((_11 as Err).0: std::fmt::Error) +15:13-15:31: @9.Call: _14 = std::fmt::Arguments::new_v1(move _15, move _19) -> [return: bb10, unwind: bb21] +15:13-15:31: @10.Call: _12 = std::fmt::Formatter::write_fmt(move _13, move _14) -> [return: bb11, unwind: bb21]"><span class="annotation">@9,10,11,12⦊</span>write!(f, "error")<span class="annotation">⦉@9,10,11,12</span></span></span><span><span class="code even" style="--layer: 1" title="15:31-15:32: @16[1]: _25 = ((_11 as Err).0: std::fmt::Error) 15:31-15:32: @16[4]: _28 = _25 -15:31-15:32: @16.Call: _27 = <std::fmt::Error as From<std::fmt::Error>>::from(move _28) -> [return: bb17, unwind: bb21]"><span class="annotation">@14,16,17,18⦊</span>?<span class="annotation">⦉@14,16,17,18</span></span></span><span class="code" style="--layer: 0">;</span></span> +15:31-15:32: @16.Call: _27 = <std::fmt::Error as std::convert::From<std::fmt::Error>>::from(move _28) -> [return: bb17, unwind: bb21]"><span class="annotation">@14,16,17,18⦊</span>?<span class="annotation">⦉@14,16,17,18</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> } else </span><span><span class="code odd" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>{</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()"> }<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="18:12-18:14: @19[3]: _30 = () diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html index c7992614b5b..013c292ce9a 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html @@ -69,9 +69,9 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -81,9 +81,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -93,9 +93,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -105,9 +105,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -117,9 +117,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -129,9 +129,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -141,9 +141,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -153,9 +153,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"> let mut a: u8 = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 @@ -165,9 +165,9 @@ For revisions in Pull Requests (PR): 10:9-10:14: @3[7]: FakeRead(ForLet, _6) 10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] }) 11:8-11:15: @3[11]: _8 = _1"> let mut b: u8 = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb37] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb37] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb36] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:21-9:22: @3[2]: _5 = const 0_u8 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html index 4dcf6c741dc..1abc24156d9 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html @@ -69,23 +69,23 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 0"><span class="line"><span><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb32] +<div class="code" style="counter-reset: line 0"><span class="line"><span><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb32] 2:19-2:35: @1[0]: _3 = &_4 -2:19-2:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb31] +2:19-2:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb31] 2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize) 2:9-2:16: @2[3]: FakeRead(ForLet, _1) 3:25-3:27: @3[2]: _5 = const 10_i32 3:9-3:22: @3[3]: FakeRead(ForLet, _5)"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb32] +<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb32] 2:19-2:35: @1[0]: _3 = &_4 -2:19-2:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb31] +2:19-2:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb31] 2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize) 2:9-2:16: @2[3]: FakeRead(ForLet, _1) 3:25-3:27: @3[2]: _5 = const 10_i32 3:9-3:22: @3[3]: FakeRead(ForLet, _5)"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb32] +<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb32] 2:19-2:35: @1[0]: _3 = &_4 -2:19-2:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb31] +2:19-2:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb31] 2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize) 2:9-2:16: @2[3]: FakeRead(ForLet, _1) 3:25-3:27: @3[2]: _5 = const 10_i32 @@ -107,7 +107,7 @@ For revisions in Pull Requests (PR): 8:13-8:14: @16[4]: _15 = move _22 8:13-8:14: @16[5]: _16 = const ()"><span class="annotation">@14,16⦊</span>_<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> in </span><span><span class="code even" style="--layer: 1" title="8:18-8:23: @11[5]: _19 = &mut _14 8:18-8:23: @11[6]: _18 = &mut (*_19) -8:18-8:23: @11.Call: _17 = <std::ops::Range<i32> as Iterator>::next(move _18) -> [return: bb12, unwind: bb32] +8:18-8:23: @11.Call: _17 = <std::ops::Range<i32> as std::iter::Iterator>::next(move _18) -> [return: bb12, unwind: bb32] 8:18-8:23: @12[1]: FakeRead(ForMatchedPlace, _17)"><span class="annotation">@10,11,12⦊</span>0..50<span class="annotation">⦉@10,11,12</span></span></span><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> if </span><span><span class="code odd" style="--layer: 1" title="9:16-9:17: @16[15]: _27 = _9 9:16-9:22: @16[16]: _26 = Lt(move _27, const 30_i32)"><span class="annotation">@14,16⦊</span>a < 30<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> {</span></span> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html index ca3515689d3..2a9b1b10efc 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html @@ -89,13 +89,13 @@ For revisions in Pull Requests (PR): 20:13-20:44: @8[23]: _23 = (_21.0: &u32) 20:13-20:44: @8[26]: _25 = &(*_23) 20:13-20:44: @8[28]: _26 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -20:13-20:44: @8.Call: _24 = ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] +20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] 20:13-20:44: @9[2]: _20 = [move _24] 20:13-20:44: @9[5]: _19 = &_20 20:13-20:44: @9[6]: _18 = &(*_19) 20:13-20:44: @9[7]: _17 = move _18 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -20:13-20:44: @9.Call: _12 = Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] -20:13-20:44: @10.Call: _11 = _print(move _12) -> [return: bb11, unwind: bb21] +20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] +20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -> [return: bb11, unwind: bb21] 20:13-20:44: @11[6]: _10 = const () 18:27-21:10: @11[8]: _6 = const ()"><span class="annotation">@6,8,9,10,11⦊</span>{</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="19:26-19:44: @6.Call: _9 = might_overflow(const 10_u32) -> [return: bb8, unwind: bb21] @@ -110,13 +110,13 @@ For revisions in Pull Requests (PR): 20:13-20:44: @8[23]: _23 = (_21.0: &u32) 20:13-20:44: @8[26]: _25 = &(*_23) 20:13-20:44: @8[28]: _26 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -20:13-20:44: @8.Call: _24 = ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] +20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] 20:13-20:44: @9[2]: _20 = [move _24] 20:13-20:44: @9[5]: _19 = &_20 20:13-20:44: @9[6]: _18 = &(*_19) 20:13-20:44: @9[7]: _17 = move _18 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -20:13-20:44: @9.Call: _12 = Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] -20:13-20:44: @10.Call: _11 = _print(move _12) -> [return: bb11, unwind: bb21] +20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] +20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -> [return: bb11, unwind: bb21] 20:13-20:44: @11[6]: _10 = const () 18:27-21:10: @11[8]: _6 = const ()"> let result = might_overflow(10);</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="19:26-19:44: @6.Call: _9 = might_overflow(const 10_u32) -> [return: bb8, unwind: bb21] @@ -131,13 +131,13 @@ For revisions in Pull Requests (PR): 20:13-20:44: @8[23]: _23 = (_21.0: &u32) 20:13-20:44: @8[26]: _25 = &(*_23) 20:13-20:44: @8[28]: _26 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -20:13-20:44: @8.Call: _24 = ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] +20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] 20:13-20:44: @9[2]: _20 = [move _24] 20:13-20:44: @9[5]: _19 = &_20 20:13-20:44: @9[6]: _18 = &(*_19) 20:13-20:44: @9[7]: _17 = move _18 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -20:13-20:44: @9.Call: _12 = Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] -20:13-20:44: @10.Call: _11 = _print(move _12) -> [return: bb11, unwind: bb21] +20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] +20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -> [return: bb11, unwind: bb21] 20:13-20:44: @11[6]: _10 = const () 18:27-21:10: @11[8]: _6 = const ()"> println!("Result: {}", result);</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="19:26-19:44: @6.Call: _9 = might_overflow(const 10_u32) -> [return: bb8, unwind: bb21] @@ -152,13 +152,13 @@ For revisions in Pull Requests (PR): 20:13-20:44: @8[23]: _23 = (_21.0: &u32) 20:13-20:44: @8[26]: _25 = &(*_23) 20:13-20:44: @8[28]: _26 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -20:13-20:44: @8.Call: _24 = ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] +20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::<u32>(move _25, move _26) -> [return: bb9, unwind: bb21] 20:13-20:44: @9[2]: _20 = [move _24] 20:13-20:44: @9[5]: _19 = &_20 20:13-20:44: @9[6]: _18 = &(*_19) 20:13-20:44: @9[7]: _17 = move _18 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -20:13-20:44: @9.Call: _12 = Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] -20:13-20:44: @10.Call: _11 = _print(move _12) -> [return: bb11, unwind: bb21] +20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -> [return: bb10, unwind: bb21] +20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -> [return: bb11, unwind: bb21] 20:13-20:44: @11[6]: _10 = const () 18:27-21:10: @11[8]: _6 = const ()"> }<span class="annotation">⦉@6,8,9,10,11</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code even" style="--layer: 1" title="21:19-21:28: @7[2]: _28 = _1 21:19-21:32: @7[3]: _27 = Lt(move _28, const 5_i32)"><span class="annotation">@7⦊</span>countdown < 5<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -> [return: bb14, unwind: bb21] @@ -173,13 +173,13 @@ For revisions in Pull Requests (PR): 23:13-23:44: @14[23]: _43 = (_41.0: &u32) 23:13-23:44: @14[26]: _45 = &(*_43) 23:13-23:44: @14[28]: _46 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -23:13-23:44: @14.Call: _44 = ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] +23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] 23:13-23:44: @15[2]: _40 = [move _44] 23:13-23:44: @15[5]: _39 = &_40 23:13-23:44: @15[6]: _38 = &(*_39) 23:13-23:44: @15[7]: _37 = move _38 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -23:13-23:44: @15.Call: _32 = Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] -23:13-23:44: @16.Call: _31 = _print(move _32) -> [return: bb17, unwind: bb21] +23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] +23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -> [return: bb17, unwind: bb21] 23:13-23:44: @17[6]: _30 = const () 21:33-24:10: @17[8]: _6 = const ()"><span class="annotation">@12,14,15,16,17⦊</span>{</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -> [return: bb14, unwind: bb21] @@ -194,13 +194,13 @@ For revisions in Pull Requests (PR): 23:13-23:44: @14[23]: _43 = (_41.0: &u32) 23:13-23:44: @14[26]: _45 = &(*_43) 23:13-23:44: @14[28]: _46 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -23:13-23:44: @14.Call: _44 = ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] +23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] 23:13-23:44: @15[2]: _40 = [move _44] 23:13-23:44: @15[5]: _39 = &_40 23:13-23:44: @15[6]: _38 = &(*_39) 23:13-23:44: @15[7]: _37 = move _38 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -23:13-23:44: @15.Call: _32 = Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] -23:13-23:44: @16.Call: _31 = _print(move _32) -> [return: bb17, unwind: bb21] +23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] +23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -> [return: bb17, unwind: bb21] 23:13-23:44: @17[6]: _30 = const () 21:33-24:10: @17[8]: _6 = const ()"> let result = might_overflow(1);</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -> [return: bb14, unwind: bb21] @@ -215,13 +215,13 @@ For revisions in Pull Requests (PR): 23:13-23:44: @14[23]: _43 = (_41.0: &u32) 23:13-23:44: @14[26]: _45 = &(*_43) 23:13-23:44: @14[28]: _46 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -23:13-23:44: @14.Call: _44 = ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] +23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] 23:13-23:44: @15[2]: _40 = [move _44] 23:13-23:44: @15[5]: _39 = &_40 23:13-23:44: @15[6]: _38 = &(*_39) 23:13-23:44: @15[7]: _37 = move _38 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -23:13-23:44: @15.Call: _32 = Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] -23:13-23:44: @16.Call: _31 = _print(move _32) -> [return: bb17, unwind: bb21] +23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] +23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -> [return: bb17, unwind: bb21] 23:13-23:44: @17[6]: _30 = const () 21:33-24:10: @17[8]: _6 = const ()"> println!("Result: {}", result);</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -> [return: bb14, unwind: bb21] @@ -236,13 +236,13 @@ For revisions in Pull Requests (PR): 23:13-23:44: @14[23]: _43 = (_41.0: &u32) 23:13-23:44: @14[26]: _45 = &(*_43) 23:13-23:44: @14[28]: _46 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -23:13-23:44: @14.Call: _44 = ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] +23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::<u32>(move _45, move _46) -> [return: bb15, unwind: bb21] 23:13-23:44: @15[2]: _40 = [move _44] 23:13-23:44: @15[5]: _39 = &_40 23:13-23:44: @15[6]: _38 = &(*_39) 23:13-23:44: @15[7]: _37 = move _38 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -23:13-23:44: @15.Call: _32 = Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] -23:13-23:44: @16.Call: _31 = _print(move _32) -> [return: bb17, unwind: bb21] +23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -> [return: bb16, unwind: bb21] +23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -> [return: bb17, unwind: bb21] 23:13-23:44: @17[6]: _30 = const () 21:33-24:10: @17[8]: _6 = const ()"> }<span class="annotation">⦉@12,14,15,16,17</span></span></span><span><span class="code even" style="--layer: 1" title="24:10-24:10: @13[0]: _6 = const ()"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="25:9-25:23: @19[2]: _47 = CheckedSub(_1, const 1_i32) diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html index f86cc4b2d2a..c6043f0bd07 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html @@ -82,8 +82,8 @@ For revisions in Pull Requests (PR): 6:9-6:49: @1[18]: _14 = &(*_60) 6:9-6:49: @1[19]: _13 = &(*_14) 6:9-6:49: @1[20]: _12 = move _13 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -6:9-6:49: @1.Call: _7 = Arguments::new_v1(move _8, move _12) -> [return: bb3, unwind: bb14] -6:9-6:49: @3.Call: _6 = _print(move _7) -> [return: bb4, unwind: bb14] +6:9-6:49: @1.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -> [return: bb3, unwind: bb14] +6:9-6:49: @3.Call: _6 = std::io::_print(move _7) -> [return: bb4, unwind: bb14] 6:9-6:49: @4[5]: _5 = const () 5:19-7:6: @4[7]: _2 = const ()"><span class="annotation">@1,3,4⦊</span>{</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="6:18-6:47: @1[6]: _61 = const might_overflow::promoted[4] @@ -96,8 +96,8 @@ For revisions in Pull Requests (PR): 6:9-6:49: @1[18]: _14 = &(*_60) 6:9-6:49: @1[19]: _13 = &(*_14) 6:9-6:49: @1[20]: _12 = move _13 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -6:9-6:49: @1.Call: _7 = Arguments::new_v1(move _8, move _12) -> [return: bb3, unwind: bb14] -6:9-6:49: @3.Call: _6 = _print(move _7) -> [return: bb4, unwind: bb14] +6:9-6:49: @1.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -> [return: bb3, unwind: bb14] +6:9-6:49: @3.Call: _6 = std::io::_print(move _7) -> [return: bb4, unwind: bb14] 6:9-6:49: @4[5]: _5 = const () 5:19-7:6: @4[7]: _2 = const ()"> println!("this will probably overflow");</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="6:18-6:47: @1[6]: _61 = const might_overflow::promoted[4] @@ -110,8 +110,8 @@ For revisions in Pull Requests (PR): 6:9-6:49: @1[18]: _14 = &(*_60) 6:9-6:49: @1[19]: _13 = &(*_14) 6:9-6:49: @1[20]: _12 = move _13 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -6:9-6:49: @1.Call: _7 = Arguments::new_v1(move _8, move _12) -> [return: bb3, unwind: bb14] -6:9-6:49: @3.Call: _6 = _print(move _7) -> [return: bb4, unwind: bb14] +6:9-6:49: @1.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -> [return: bb3, unwind: bb14] +6:9-6:49: @3.Call: _6 = std::io::_print(move _7) -> [return: bb4, unwind: bb14] 6:9-6:49: @4[5]: _5 = const () 5:19-7:6: @4[7]: _2 = const ()"> }<span class="annotation">⦉@1,3,4</span></span></span><span><span class="code even" style="--layer: 1" title="7:6-7:6: @2[0]: _2 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code odd" style="--layer: 1" title="8:18-8:30: @5[3]: _18 = CheckedSub(const core::num::<impl u32>::MAX, const 5_u32) @@ -129,16 +129,16 @@ For revisions in Pull Requests (PR): 9:5-9:56: @6[29]: _34 = (_30.1: &u32) 9:5-9:56: @6[32]: _36 = &(*_33) 9:5-9:56: @6[34]: _37 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @6.Call: _35 = ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] +9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] 9:5-9:56: @7[4]: _39 = &(*_34) 9:5-9:56: @7[6]: _40 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @7.Call: _38 = ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] +9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] 9:5-9:56: @8[2]: _29 = [move _35, move _38] 9:5-9:56: @8[7]: _28 = &_29 9:5-9:56: @8[8]: _27 = &(*_28) 9:5-9:56: @8[9]: _26 = move _27 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:5-9:56: @8.Call: _21 = Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] -9:5-9:56: @9.Call: _20 = _print(move _21) -> [return: bb10, unwind: bb14] +9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] +9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -> [return: bb10, unwind: bb14] 9:5-9:56: @10[6]: _19 = const () 10:18-10:24: @10[10]: _42 = _1 10:27-10:33: @10[12]: _43 = _17 @@ -155,8 +155,8 @@ For revisions in Pull Requests (PR): 11:5-11:49: @11[22]: _54 = &(*_57) 11:5-11:49: @11[23]: _53 = &(*_54) 11:5-11:49: @11[24]: _52 = move _53 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-11:49: @11.Call: _47 = Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] -11:5-11:49: @12.Call: _46 = _print(move _47) -> [return: bb13, unwind: bb14] +11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] +11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -> [return: bb13, unwind: bb14] 11:5-11:49: @13[5]: _45 = const () 12:5-12:11: @13[7]: _0 = _41 13:2-13:2: @13.Return: return"><span class="annotation">@5,6,7,8,9,10,11,12,13⦊</span>add_to = u32::MAX - 5;</span></span> @@ -175,16 +175,16 @@ For revisions in Pull Requests (PR): 9:5-9:56: @6[29]: _34 = (_30.1: &u32) 9:5-9:56: @6[32]: _36 = &(*_33) 9:5-9:56: @6[34]: _37 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @6.Call: _35 = ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] +9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] 9:5-9:56: @7[4]: _39 = &(*_34) 9:5-9:56: @7[6]: _40 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @7.Call: _38 = ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] +9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] 9:5-9:56: @8[2]: _29 = [move _35, move _38] 9:5-9:56: @8[7]: _28 = &_29 9:5-9:56: @8[8]: _27 = &(*_28) 9:5-9:56: @8[9]: _26 = move _27 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:5-9:56: @8.Call: _21 = Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] -9:5-9:56: @9.Call: _20 = _print(move _21) -> [return: bb10, unwind: bb14] +9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] +9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -> [return: bb10, unwind: bb14] 9:5-9:56: @10[6]: _19 = const () 10:18-10:24: @10[10]: _42 = _1 10:27-10:33: @10[12]: _43 = _17 @@ -201,8 +201,8 @@ For revisions in Pull Requests (PR): 11:5-11:49: @11[22]: _54 = &(*_57) 11:5-11:49: @11[23]: _53 = &(*_54) 11:5-11:49: @11[24]: _52 = move _53 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-11:49: @11.Call: _47 = Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] -11:5-11:49: @12.Call: _46 = _print(move _47) -> [return: bb13, unwind: bb14] +11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] +11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -> [return: bb13, unwind: bb14] 11:5-11:49: @13[5]: _45 = const () 12:5-12:11: @13[7]: _0 = _41 13:2-13:2: @13.Return: return"> println!("does {} + {} overflow?", add_to, to_add);</span></span> @@ -221,16 +221,16 @@ For revisions in Pull Requests (PR): 9:5-9:56: @6[29]: _34 = (_30.1: &u32) 9:5-9:56: @6[32]: _36 = &(*_33) 9:5-9:56: @6[34]: _37 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @6.Call: _35 = ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] +9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] 9:5-9:56: @7[4]: _39 = &(*_34) 9:5-9:56: @7[6]: _40 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @7.Call: _38 = ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] +9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] 9:5-9:56: @8[2]: _29 = [move _35, move _38] 9:5-9:56: @8[7]: _28 = &_29 9:5-9:56: @8[8]: _27 = &(*_28) 9:5-9:56: @8[9]: _26 = move _27 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:5-9:56: @8.Call: _21 = Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] -9:5-9:56: @9.Call: _20 = _print(move _21) -> [return: bb10, unwind: bb14] +9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] +9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -> [return: bb10, unwind: bb14] 9:5-9:56: @10[6]: _19 = const () 10:18-10:24: @10[10]: _42 = _1 10:27-10:33: @10[12]: _43 = _17 @@ -247,8 +247,8 @@ For revisions in Pull Requests (PR): 11:5-11:49: @11[22]: _54 = &(*_57) 11:5-11:49: @11[23]: _53 = &(*_54) 11:5-11:49: @11[24]: _52 = move _53 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-11:49: @11.Call: _47 = Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] -11:5-11:49: @12.Call: _46 = _print(move _47) -> [return: bb13, unwind: bb14] +11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] +11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -> [return: bb13, unwind: bb14] 11:5-11:49: @13[5]: _45 = const () 12:5-12:11: @13[7]: _0 = _41 13:2-13:2: @13.Return: return"> let result = to_add + add_to;</span></span> @@ -267,16 +267,16 @@ For revisions in Pull Requests (PR): 9:5-9:56: @6[29]: _34 = (_30.1: &u32) 9:5-9:56: @6[32]: _36 = &(*_33) 9:5-9:56: @6[34]: _37 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @6.Call: _35 = ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] +9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] 9:5-9:56: @7[4]: _39 = &(*_34) 9:5-9:56: @7[6]: _40 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @7.Call: _38 = ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] +9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] 9:5-9:56: @8[2]: _29 = [move _35, move _38] 9:5-9:56: @8[7]: _28 = &_29 9:5-9:56: @8[8]: _27 = &(*_28) 9:5-9:56: @8[9]: _26 = move _27 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:5-9:56: @8.Call: _21 = Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] -9:5-9:56: @9.Call: _20 = _print(move _21) -> [return: bb10, unwind: bb14] +9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] +9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -> [return: bb10, unwind: bb14] 9:5-9:56: @10[6]: _19 = const () 10:18-10:24: @10[10]: _42 = _1 10:27-10:33: @10[12]: _43 = _17 @@ -293,8 +293,8 @@ For revisions in Pull Requests (PR): 11:5-11:49: @11[22]: _54 = &(*_57) 11:5-11:49: @11[23]: _53 = &(*_54) 11:5-11:49: @11[24]: _52 = move _53 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-11:49: @11.Call: _47 = Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] -11:5-11:49: @12.Call: _46 = _print(move _47) -> [return: bb13, unwind: bb14] +11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] +11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -> [return: bb13, unwind: bb14] 11:5-11:49: @13[5]: _45 = const () 12:5-12:11: @13[7]: _0 = _41 13:2-13:2: @13.Return: return"> println!("continuing after overflow check");</span></span> @@ -313,16 +313,16 @@ For revisions in Pull Requests (PR): 9:5-9:56: @6[29]: _34 = (_30.1: &u32) 9:5-9:56: @6[32]: _36 = &(*_33) 9:5-9:56: @6[34]: _37 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @6.Call: _35 = ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] +9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] 9:5-9:56: @7[4]: _39 = &(*_34) 9:5-9:56: @7[6]: _40 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @7.Call: _38 = ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] +9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] 9:5-9:56: @8[2]: _29 = [move _35, move _38] 9:5-9:56: @8[7]: _28 = &_29 9:5-9:56: @8[8]: _27 = &(*_28) 9:5-9:56: @8[9]: _26 = move _27 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:5-9:56: @8.Call: _21 = Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] -9:5-9:56: @9.Call: _20 = _print(move _21) -> [return: bb10, unwind: bb14] +9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] +9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -> [return: bb10, unwind: bb14] 9:5-9:56: @10[6]: _19 = const () 10:18-10:24: @10[10]: _42 = _1 10:27-10:33: @10[12]: _43 = _17 @@ -339,8 +339,8 @@ For revisions in Pull Requests (PR): 11:5-11:49: @11[22]: _54 = &(*_57) 11:5-11:49: @11[23]: _53 = &(*_54) 11:5-11:49: @11[24]: _52 = move _53 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-11:49: @11.Call: _47 = Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] -11:5-11:49: @12.Call: _46 = _print(move _47) -> [return: bb13, unwind: bb14] +11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] +11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -> [return: bb13, unwind: bb14] 11:5-11:49: @13[5]: _45 = const () 12:5-12:11: @13[7]: _0 = _41 13:2-13:2: @13.Return: return"> result</span></span> @@ -359,16 +359,16 @@ For revisions in Pull Requests (PR): 9:5-9:56: @6[29]: _34 = (_30.1: &u32) 9:5-9:56: @6[32]: _36 = &(*_33) 9:5-9:56: @6[34]: _37 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @6.Call: _35 = ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] +9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::<u32>(move _36, move _37) -> [return: bb7, unwind: bb14] 9:5-9:56: @7[4]: _39 = &(*_34) 9:5-9:56: @7[6]: _40 = <u32 as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r u32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -9:5-9:56: @7.Call: _38 = ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] +9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::<u32>(move _39, move _40) -> [return: bb8, unwind: bb14] 9:5-9:56: @8[2]: _29 = [move _35, move _38] 9:5-9:56: @8[7]: _28 = &_29 9:5-9:56: @8[8]: _27 = &(*_28) 9:5-9:56: @8[9]: _26 = move _27 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:5-9:56: @8.Call: _21 = Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] -9:5-9:56: @9.Call: _20 = _print(move _21) -> [return: bb10, unwind: bb14] +9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -> [return: bb9, unwind: bb14] +9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -> [return: bb10, unwind: bb14] 9:5-9:56: @10[6]: _19 = const () 10:18-10:24: @10[10]: _42 = _1 10:27-10:33: @10[12]: _43 = _17 @@ -385,8 +385,8 @@ For revisions in Pull Requests (PR): 11:5-11:49: @11[22]: _54 = &(*_57) 11:5-11:49: @11[23]: _53 = &(*_54) 11:5-11:49: @11[24]: _52 = move _53 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -11:5-11:49: @11.Call: _47 = Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] -11:5-11:49: @12.Call: _46 = _print(move _47) -> [return: bb13, unwind: bb14] +11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -> [return: bb12, unwind: bb14] +11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -> [return: bb13, unwind: bb14] 11:5-11:49: @13[5]: _45 = const () 12:5-12:11: @13[7]: _0 = _41 13:2-13:2: @13.Return: return">}<span class="annotation">⦉@5,6,7,8,9,10,11,12,13</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html index 86d9875b47c..32988629ba0 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html @@ -81,10 +81,10 @@ For revisions in Pull Requests (PR): 6:9-6:34: @1[18]: _13 = &(*_32) 6:9-6:34: @1[19]: _12 = &(*_13) 6:9-6:34: @1[20]: _11 = move _12 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -6:9-6:34: @1.Call: _6 = Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] -6:9-6:34: @3.Call: _5 = _print(move _6) -> [return: bb4, unwind: bb7] +6:9-6:34: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] +6:9-6:34: @3.Call: _5 = std::io::_print(move _6) -> [return: bb4, unwind: bb7] 6:9-6:34: @4[5]: _4 = const () -7:9-7:26: @4.Call: begin_panic::<&str>(const "panics") -> bb7"><span class="annotation">@1,3,4⦊</span>println!("panicking...");</span></span> +7:9-7:26: @4.Call: std::rt::begin_panic::<&str>(const "panics") -> bb7"><span class="annotation">@1,3,4⦊</span>println!("panicking...");</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="6:18-6:32: @1[6]: _33 = const might_panic::promoted[3] 6:18-6:32: @1[7]: _9 = &(*_33) 6:18-6:32: @1[8]: _8 = &(*_9) @@ -95,10 +95,10 @@ For revisions in Pull Requests (PR): 6:9-6:34: @1[18]: _13 = &(*_32) 6:9-6:34: @1[19]: _12 = &(*_13) 6:9-6:34: @1[20]: _11 = move _12 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -6:9-6:34: @1.Call: _6 = Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] -6:9-6:34: @3.Call: _5 = _print(move _6) -> [return: bb4, unwind: bb7] +6:9-6:34: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -> [return: bb3, unwind: bb7] +6:9-6:34: @3.Call: _5 = std::io::_print(move _6) -> [return: bb4, unwind: bb7] 6:9-6:34: @4[5]: _4 = const () -7:9-7:26: @4.Call: begin_panic::<&str>(const "panics") -> bb7"> panic!("panics");<span class="annotation">⦉@1,3,4</span></span></span><span class="code" style="--layer: 0"></span></span> +7:9-7:26: @4.Call: std::rt::begin_panic::<&str>(const "panics") -> bb7"> panic!("panics");<span class="annotation">⦉@1,3,4</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> } else </span><span><span class="code even" style="--layer: 1" title="9:18-9:31: @2[6]: _31 = const might_panic::promoted[1] 9:18-9:31: @2[7]: _23 = &(*_31) 9:18-9:31: @2[8]: _22 = &(*_23) @@ -109,8 +109,8 @@ For revisions in Pull Requests (PR): 9:9-9:33: @2[18]: _27 = &(*_30) 9:9-9:33: @2[19]: _26 = &(*_27) 9:9-9:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:9-9:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -9:9-9:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 9:9-9:33: @6[5]: _18 = const () 8:12-10:6: @6[7]: _0 = const () 11:2-11:2: @6.Return: return"><span class="annotation">@2,5,6⦊</span>{</span></span> @@ -124,8 +124,8 @@ For revisions in Pull Requests (PR): 9:9-9:33: @2[18]: _27 = &(*_30) 9:9-9:33: @2[19]: _26 = &(*_27) 9:9-9:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:9-9:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -9:9-9:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 9:9-9:33: @6[5]: _18 = const () 8:12-10:6: @6[7]: _0 = const () 11:2-11:2: @6.Return: return"> println!("Don't Panic");</span></span> @@ -139,8 +139,8 @@ For revisions in Pull Requests (PR): 9:9-9:33: @2[18]: _27 = &(*_30) 9:9-9:33: @2[19]: _26 = &(*_27) 9:9-9:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:9-9:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -9:9-9:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 9:9-9:33: @6[5]: _18 = const () 8:12-10:6: @6[7]: _0 = const () 11:2-11:2: @6.Return: return"> }</span></span> @@ -154,8 +154,8 @@ For revisions in Pull Requests (PR): 9:9-9:33: @2[18]: _27 = &(*_30) 9:9-9:33: @2[19]: _26 = &(*_27) 9:9-9:33: @2[20]: _25 = move _26 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -9:9-9:33: @2.Call: _20 = Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] -9:9-9:33: @5.Call: _19 = _print(move _20) -> [return: bb6, unwind: bb7] +9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -> [return: bb5, unwind: bb7] +9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -> [return: bb6, unwind: bb7] 9:9-9:33: @6[5]: _18 = const () 8:12-10:6: @6[7]: _0 = const () 11:2-11:2: @6.Return: return">}<span class="annotation">⦉@2,5,6</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html index 6d9d63deccf..3e307c4f460 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html @@ -81,7 +81,7 @@ For revisions in Pull Requests (PR): 25:49-25:62: @2[20]: _16 = &_2 25:64-25:77: @2[24]: _19 = &_1 25:80-25:93: @2[26]: _20 = &_2 -25:64-25:93: @2.Call: _18 = <Version as PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] +25:64-25:93: @2.Call: _18 = <Version as std::cmp::PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] 25:64-25:93: @3[2]: _17 = &_18 25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17) 25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14) @@ -89,20 +89,20 @@ For revisions in Pull Requests (PR): 25:5-25:95: @3[11]: _22 = (_14.1: &Version) 25:5-25:95: @3[13]: _23 = (_14.2: &bool) 25:5-25:95: @3[16]: _25 = &(*_21) -25:5-25:95: @3[18]: _26 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @3.Call: _24 = ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] +25:5-25:95: @3[18]: _26 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] 25:5-25:95: @4[4]: _28 = &(*_22) -25:5-25:95: @4[6]: _29 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @4.Call: _27 = ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] +25:5-25:95: @4[6]: _29 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] 25:5-25:95: @5[4]: _31 = &(*_23) 25:5-25:95: @5[6]: _32 = <bool as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r bool, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @5.Call: _30 = ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] +25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] 25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30] 25:5-25:95: @6[9]: _12 = &_13 25:5-25:95: @6[10]: _11 = &(*_12) 25:5-25:95: @6[11]: _10 = move _11 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] -25:5-25:95: @7.Call: _4 = _print(move _5) -> [return: bb8, unwind: bb9] +25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] +25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -> [return: bb8, unwind: bb9] 25:5-25:95: @8[7]: _3 = const () 21:11-26:2: @8[9]: _0 = const () 26:2-26:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>fn main() {</span></span> @@ -118,7 +118,7 @@ For revisions in Pull Requests (PR): 25:49-25:62: @2[20]: _16 = &_2 25:64-25:77: @2[24]: _19 = &_1 25:80-25:93: @2[26]: _20 = &_2 -25:64-25:93: @2.Call: _18 = <Version as PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] +25:64-25:93: @2.Call: _18 = <Version as std::cmp::PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] 25:64-25:93: @3[2]: _17 = &_18 25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17) 25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14) @@ -126,20 +126,20 @@ For revisions in Pull Requests (PR): 25:5-25:95: @3[11]: _22 = (_14.1: &Version) 25:5-25:95: @3[13]: _23 = (_14.2: &bool) 25:5-25:95: @3[16]: _25 = &(*_21) -25:5-25:95: @3[18]: _26 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @3.Call: _24 = ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] +25:5-25:95: @3[18]: _26 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] 25:5-25:95: @4[4]: _28 = &(*_22) -25:5-25:95: @4[6]: _29 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @4.Call: _27 = ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] +25:5-25:95: @4[6]: _29 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] 25:5-25:95: @5[4]: _31 = &(*_23) 25:5-25:95: @5[6]: _32 = <bool as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r bool, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @5.Call: _30 = ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] +25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] 25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30] 25:5-25:95: @6[9]: _12 = &_13 25:5-25:95: @6[10]: _11 = &(*_12) 25:5-25:95: @6[11]: _10 = move _11 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] -25:5-25:95: @7.Call: _4 = _print(move _5) -> [return: bb8, unwind: bb9] +25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] +25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -> [return: bb8, unwind: bb9] 25:5-25:95: @8[7]: _3 = const () 21:11-26:2: @8[9]: _0 = const () 26:2-26:2: @8.Return: return"> let version_3_2_1 = Version::new(3, 2, 1);</span></span> @@ -155,7 +155,7 @@ For revisions in Pull Requests (PR): 25:49-25:62: @2[20]: _16 = &_2 25:64-25:77: @2[24]: _19 = &_1 25:80-25:93: @2[26]: _20 = &_2 -25:64-25:93: @2.Call: _18 = <Version as PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] +25:64-25:93: @2.Call: _18 = <Version as std::cmp::PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] 25:64-25:93: @3[2]: _17 = &_18 25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17) 25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14) @@ -163,20 +163,20 @@ For revisions in Pull Requests (PR): 25:5-25:95: @3[11]: _22 = (_14.1: &Version) 25:5-25:95: @3[13]: _23 = (_14.2: &bool) 25:5-25:95: @3[16]: _25 = &(*_21) -25:5-25:95: @3[18]: _26 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @3.Call: _24 = ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] +25:5-25:95: @3[18]: _26 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] 25:5-25:95: @4[4]: _28 = &(*_22) -25:5-25:95: @4[6]: _29 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @4.Call: _27 = ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] +25:5-25:95: @4[6]: _29 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] 25:5-25:95: @5[4]: _31 = &(*_23) 25:5-25:95: @5[6]: _32 = <bool as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r bool, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @5.Call: _30 = ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] +25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] 25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30] 25:5-25:95: @6[9]: _12 = &_13 25:5-25:95: @6[10]: _11 = &(*_12) 25:5-25:95: @6[11]: _10 = move _11 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] -25:5-25:95: @7.Call: _4 = _print(move _5) -> [return: bb8, unwind: bb9] +25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] +25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -> [return: bb8, unwind: bb9] 25:5-25:95: @8[7]: _3 = const () 21:11-26:2: @8[9]: _0 = const () 26:2-26:2: @8.Return: return"> let version_3_3_0 = Version::new(3, 3, 0);</span></span> @@ -192,7 +192,7 @@ For revisions in Pull Requests (PR): 25:49-25:62: @2[20]: _16 = &_2 25:64-25:77: @2[24]: _19 = &_1 25:80-25:93: @2[26]: _20 = &_2 -25:64-25:93: @2.Call: _18 = <Version as PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] +25:64-25:93: @2.Call: _18 = <Version as std::cmp::PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] 25:64-25:93: @3[2]: _17 = &_18 25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17) 25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14) @@ -200,20 +200,20 @@ For revisions in Pull Requests (PR): 25:5-25:95: @3[11]: _22 = (_14.1: &Version) 25:5-25:95: @3[13]: _23 = (_14.2: &bool) 25:5-25:95: @3[16]: _25 = &(*_21) -25:5-25:95: @3[18]: _26 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @3.Call: _24 = ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] +25:5-25:95: @3[18]: _26 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] 25:5-25:95: @4[4]: _28 = &(*_22) -25:5-25:95: @4[6]: _29 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @4.Call: _27 = ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] +25:5-25:95: @4[6]: _29 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] 25:5-25:95: @5[4]: _31 = &(*_23) 25:5-25:95: @5[6]: _32 = <bool as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r bool, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @5.Call: _30 = ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] +25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] 25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30] 25:5-25:95: @6[9]: _12 = &_13 25:5-25:95: @6[10]: _11 = &(*_12) 25:5-25:95: @6[11]: _10 = move _11 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] -25:5-25:95: @7.Call: _4 = _print(move _5) -> [return: bb8, unwind: bb9] +25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] +25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -> [return: bb8, unwind: bb9] 25:5-25:95: @8[7]: _3 = const () 21:11-26:2: @8[9]: _0 = const () 26:2-26:2: @8.Return: return"></span></span> @@ -229,7 +229,7 @@ For revisions in Pull Requests (PR): 25:49-25:62: @2[20]: _16 = &_2 25:64-25:77: @2[24]: _19 = &_1 25:80-25:93: @2[26]: _20 = &_2 -25:64-25:93: @2.Call: _18 = <Version as PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] +25:64-25:93: @2.Call: _18 = <Version as std::cmp::PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] 25:64-25:93: @3[2]: _17 = &_18 25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17) 25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14) @@ -237,20 +237,20 @@ For revisions in Pull Requests (PR): 25:5-25:95: @3[11]: _22 = (_14.1: &Version) 25:5-25:95: @3[13]: _23 = (_14.2: &bool) 25:5-25:95: @3[16]: _25 = &(*_21) -25:5-25:95: @3[18]: _26 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @3.Call: _24 = ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] +25:5-25:95: @3[18]: _26 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] 25:5-25:95: @4[4]: _28 = &(*_22) -25:5-25:95: @4[6]: _29 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @4.Call: _27 = ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] +25:5-25:95: @4[6]: _29 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] 25:5-25:95: @5[4]: _31 = &(*_23) 25:5-25:95: @5[6]: _32 = <bool as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r bool, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @5.Call: _30 = ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] +25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] 25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30] 25:5-25:95: @6[9]: _12 = &_13 25:5-25:95: @6[10]: _11 = &(*_12) 25:5-25:95: @6[11]: _10 = move _11 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] -25:5-25:95: @7.Call: _4 = _print(move _5) -> [return: bb8, unwind: bb9] +25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] +25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -> [return: bb8, unwind: bb9] 25:5-25:95: @8[7]: _3 = const () 21:11-26:2: @8[9]: _0 = const () 26:2-26:2: @8.Return: return"> println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0);</span></span> @@ -266,7 +266,7 @@ For revisions in Pull Requests (PR): 25:49-25:62: @2[20]: _16 = &_2 25:64-25:77: @2[24]: _19 = &_1 25:80-25:93: @2[26]: _20 = &_2 -25:64-25:93: @2.Call: _18 = <Version as PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] +25:64-25:93: @2.Call: _18 = <Version as std::cmp::PartialOrd>::lt(move _19, move _20) -> [return: bb3, unwind: bb9] 25:64-25:93: @3[2]: _17 = &_18 25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17) 25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14) @@ -274,20 +274,20 @@ For revisions in Pull Requests (PR): 25:5-25:95: @3[11]: _22 = (_14.1: &Version) 25:5-25:95: @3[13]: _23 = (_14.2: &bool) 25:5-25:95: @3[16]: _25 = &(*_21) -25:5-25:95: @3[18]: _26 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @3.Call: _24 = ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] +25:5-25:95: @3[18]: _26 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::<Version>(move _25, move _26) -> [return: bb4, unwind: bb9] 25:5-25:95: @4[4]: _28 = &(*_22) -25:5-25:95: @4[6]: _29 = <Version as Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @4.Call: _27 = ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] +25:5-25:95: @4[6]: _29 = <Version as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r Version, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::<Version>(move _28, move _29) -> [return: bb5, unwind: bb9] 25:5-25:95: @5[4]: _31 = &(*_23) 25:5-25:95: @5[6]: _32 = <bool as std::fmt::Display>::fmt as for<'r, 's, 't0> fn(&'r bool, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -25:5-25:95: @5.Call: _30 = ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] +25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::<bool>(move _31, move _32) -> [return: bb6, unwind: bb9] 25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30] 25:5-25:95: @6[9]: _12 = &_13 25:5-25:95: @6[10]: _11 = &(*_12) 25:5-25:95: @6[11]: _10 = move _11 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] -25:5-25:95: @7.Call: _4 = _print(move _5) -> [return: bb8, unwind: bb9] +25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -> [return: bb7, unwind: bb9] +25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -> [return: bb8, unwind: bb9] 25:5-25:95: @8[7]: _3 = const () 21:11-26:2: @8[9]: _0 = const () 26:2-26:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html index 47f9ab2bd5e..3954fc3d0bd 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 8:5-8:17: @0[4]: _3 = &(*_4) 8:5-8:17: @0[7]: _6 = &(*(*(_1.1: &&usize))) 8:5-8:17: @0[8]: _5 = &(*_6) -8:5-8:17: @0.Call: _2 = <usize as PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] -8:5-8:17: @1[3]: _7 = Less -8:5-8:17: @1.Call: _0 = Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] +8:5-8:17: @0.Call: _2 = <usize as std::cmp::PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] +8:5-8:17: @1[3]: _7 = std::cmp::Ordering::Less +8:5-8:17: @1.Call: _0 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] 8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html index 9f0c29c50bf..86e18b3dbfd 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 7:5-7:17: @0[5]: _4 = &(*_5) 7:5-7:17: @0[8]: _7 = &(*(*(_1.1: &&usize))) 7:5-7:17: @0[9]: _6 = &(*_7) -7:5-7:17: @0.Call: _3 = <usize as PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] -7:5-7:17: @1[3]: _8 = Equal -7:5-7:17: @1.Call: _2 = Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] +7:5-7:17: @0.Call: _3 = <usize as std::cmp::PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] +7:5-7:17: @1[3]: _8 = std::cmp::Ordering::Equal +7:5-7:17: @1.Call: _2 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] 7:5-7:17: @2[4]: _10 = &(*(_1.2: &&usize)) 7:5-7:17: @2[6]: _11 = &(*(_1.3: &&usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge.-------.InstrumentCoverage.0.html index 60a832b2e2a..652dc277081 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-ge.-------.InstrumentCoverage.0.html @@ -81,9 +81,9 @@ For revisions in Pull Requests (PR): 4:39-4:49: @0[21]: _13 = &(*_14) 4:39-4:49: @0[24]: _16 = &(*_3) 4:39-4:49: @0[25]: _15 = &(*_16) -4:39-4:49: @0.Call: _12 = <usize as PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] -4:39-4:49: @1[3]: _17 = Equal -4:39-4:49: @1.Call: _11 = Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] +4:39-4:49: @0.Call: _12 = <usize as std::cmp::PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] +4:39-4:49: @1[3]: _17 = std::cmp::Ordering::Equal +4:39-4:49: @1.Call: _11 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] 4:39-4:49: @2[4]: _19 = &_7 4:39-4:49: @2[6]: _20 = &_4 4:39-4:49: @2[8]: _21 = &_8 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html index 2b9a13fe060..57fc5d8d6de 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 8:5-8:17: @0[4]: _3 = &(*_4) 8:5-8:17: @0[7]: _6 = &(*(*(_1.1: &&usize))) 8:5-8:17: @0[8]: _5 = &(*_6) -8:5-8:17: @0.Call: _2 = <usize as PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] -8:5-8:17: @1[3]: _7 = Less -8:5-8:17: @1.Call: _0 = Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] +8:5-8:17: @0.Call: _2 = <usize as std::cmp::PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] +8:5-8:17: @1[3]: _7 = std::cmp::Ordering::Less +8:5-8:17: @1.Call: _0 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] 8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html index ff7e783dd68..6fbcdff5ab7 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 7:5-7:17: @0[5]: _4 = &(*_5) 7:5-7:17: @0[8]: _7 = &(*(*(_1.1: &&usize))) 7:5-7:17: @0[9]: _6 = &(*_7) -7:5-7:17: @0.Call: _3 = <usize as PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] -7:5-7:17: @1[3]: _8 = Equal -7:5-7:17: @1.Call: _2 = Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] +7:5-7:17: @0.Call: _3 = <usize as std::cmp::PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] +7:5-7:17: @1[3]: _8 = std::cmp::Ordering::Equal +7:5-7:17: @1.Call: _2 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] 7:5-7:17: @2[4]: _10 = &(*(_1.2: &&usize)) 7:5-7:17: @2[6]: _11 = &(*(_1.3: &&usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt.-------.InstrumentCoverage.0.html index f6b9dc9776f..37f2661cf18 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-gt.-------.InstrumentCoverage.0.html @@ -81,9 +81,9 @@ For revisions in Pull Requests (PR): 4:39-4:49: @0[21]: _13 = &(*_14) 4:39-4:49: @0[24]: _16 = &(*_3) 4:39-4:49: @0[25]: _15 = &(*_16) -4:39-4:49: @0.Call: _12 = <usize as PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] -4:39-4:49: @1[3]: _17 = Equal -4:39-4:49: @1.Call: _11 = Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] +4:39-4:49: @0.Call: _12 = <usize as std::cmp::PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] +4:39-4:49: @1[3]: _17 = std::cmp::Ordering::Equal +4:39-4:49: @1.Call: _11 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] 4:39-4:49: @2[4]: _19 = &_7 4:39-4:49: @2[6]: _20 = &_4 4:39-4:49: @2[8]: _21 = &_8 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html index 5c95a635f07..5789988c991 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 8:5-8:17: @0[4]: _3 = &(*_4) 8:5-8:17: @0[7]: _6 = &(*(*(_1.1: &&usize))) 8:5-8:17: @0[8]: _5 = &(*_6) -8:5-8:17: @0.Call: _2 = <usize as PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] -8:5-8:17: @1[3]: _7 = Greater -8:5-8:17: @1.Call: _0 = Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] +8:5-8:17: @0.Call: _2 = <usize as std::cmp::PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] +8:5-8:17: @1[3]: _7 = std::cmp::Ordering::Greater +8:5-8:17: @1.Call: _0 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] 8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html index 6eb894a166a..de7c38bc9c4 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 7:5-7:17: @0[5]: _4 = &(*_5) 7:5-7:17: @0[8]: _7 = &(*(*(_1.1: &&usize))) 7:5-7:17: @0[9]: _6 = &(*_7) -7:5-7:17: @0.Call: _3 = <usize as PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] -7:5-7:17: @1[3]: _8 = Equal -7:5-7:17: @1.Call: _2 = Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] +7:5-7:17: @0.Call: _3 = <usize as std::cmp::PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] +7:5-7:17: @1[3]: _8 = std::cmp::Ordering::Equal +7:5-7:17: @1.Call: _2 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] 7:5-7:17: @2[4]: _10 = &(*(_1.2: &&usize)) 7:5-7:17: @2[6]: _11 = &(*(_1.3: &&usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le.-------.InstrumentCoverage.0.html index fb7e520faf1..1f3068868f6 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-le.-------.InstrumentCoverage.0.html @@ -81,9 +81,9 @@ For revisions in Pull Requests (PR): 4:39-4:49: @0[21]: _13 = &(*_14) 4:39-4:49: @0[24]: _16 = &(*_3) 4:39-4:49: @0[25]: _15 = &(*_16) -4:39-4:49: @0.Call: _12 = <usize as PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] -4:39-4:49: @1[3]: _17 = Equal -4:39-4:49: @1.Call: _11 = Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] +4:39-4:49: @0.Call: _12 = <usize as std::cmp::PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] +4:39-4:49: @1[3]: _17 = std::cmp::Ordering::Equal +4:39-4:49: @1.Call: _11 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] 4:39-4:49: @2[4]: _19 = &_7 4:39-4:49: @2[6]: _20 = &_4 4:39-4:49: @2[8]: _21 = &_8 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html index b2b3e172d53..746daab5ac1 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 8:5-8:17: @0[4]: _3 = &(*_4) 8:5-8:17: @0[7]: _6 = &(*(*(_1.1: &&usize))) 8:5-8:17: @0[8]: _5 = &(*_6) -8:5-8:17: @0.Call: _2 = <usize as PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] -8:5-8:17: @1[3]: _7 = Greater -8:5-8:17: @1.Call: _0 = Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] +8:5-8:17: @0.Call: _2 = <usize as std::cmp::PartialOrd>::partial_cmp(move _3, move _5) -> [return: bb1, unwind: bb3] +8:5-8:17: @1[3]: _7 = std::cmp::Ordering::Greater +8:5-8:17: @1.Call: _0 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _2, move _7) -> [return: bb2, unwind: bb3] 8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html index e54849345b7..0867a7ad364 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html @@ -74,9 +74,9 @@ For revisions in Pull Requests (PR): 7:5-7:17: @0[5]: _4 = &(*_5) 7:5-7:17: @0[8]: _7 = &(*(*(_1.1: &&usize))) 7:5-7:17: @0[9]: _6 = &(*_7) -7:5-7:17: @0.Call: _3 = <usize as PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] -7:5-7:17: @1[3]: _8 = Equal -7:5-7:17: @1.Call: _2 = Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] +7:5-7:17: @0.Call: _3 = <usize as std::cmp::PartialOrd>::partial_cmp(move _4, move _6) -> [return: bb1, unwind: bb4] +7:5-7:17: @1[3]: _8 = std::cmp::Ordering::Equal +7:5-7:17: @1.Call: _2 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _3, move _8) -> [return: bb2, unwind: bb4] 7:5-7:17: @2[4]: _10 = &(*(_1.2: &&usize)) 7:5-7:17: @2[6]: _11 = &(*(_1.3: &&usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt.-------.InstrumentCoverage.0.html index f111ad0045a..abcd7147c6f 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-lt.-------.InstrumentCoverage.0.html @@ -81,9 +81,9 @@ For revisions in Pull Requests (PR): 4:39-4:49: @0[21]: _13 = &(*_14) 4:39-4:49: @0[24]: _16 = &(*_3) 4:39-4:49: @0[25]: _15 = &(*_16) -4:39-4:49: @0.Call: _12 = <usize as PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] -4:39-4:49: @1[3]: _17 = Equal -4:39-4:49: @1.Call: _11 = Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] +4:39-4:49: @0.Call: _12 = <usize as std::cmp::PartialOrd>::partial_cmp(move _13, move _15) -> [return: bb1, unwind: bb5] +4:39-4:49: @1[3]: _17 = std::cmp::Ordering::Equal +4:39-4:49: @1.Call: _11 = std::option::Option::<std::cmp::Ordering>::unwrap_or(move _12, move _17) -> [return: bb2, unwind: bb5] 4:39-4:49: @2[4]: _19 = &_7 4:39-4:49: @2[6]: _20 = &_4 4:39-4:49: @2[8]: _21 = &_8 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#7}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#7}-fmt.-------.InstrumentCoverage.0.html index 94c77025ecf..5b9e070864b 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#7}-fmt.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#7}-fmt.-------.InstrumentCoverage.0.html @@ -76,7 +76,7 @@ For revisions in Pull Requests (PR): 4:17-4:22: @0[9]: _7 = &mut (*_2) 4:17-4:22: @0[12]: _9 = const "Version" 4:17-4:22: @0[13]: _8 = &(*_9) -4:17-4:22: @0.Call: _6 = Formatter::debug_struct(move _7, move _8) -> [return: bb1, unwind: bb6] +4:17-4:22: @0.Call: _6 = std::fmt::Formatter::debug_struct(move _7, move _8) -> [return: bb1, unwind: bb6] 4:17-4:22: @1[2]: FakeRead(ForLet, _6) 4:17-4:22: @1[7]: _12 = &mut _6 4:17-4:22: @1[8]: _11 = &mut (*_12) @@ -86,7 +86,7 @@ For revisions in Pull Requests (PR): 4:17-4:22: @1[18]: _17 = &_18 4:17-4:22: @1[19]: _16 = &(*_17) 4:17-4:22: @1[20]: _15 = move _16 as &dyn std::fmt::Debug (Pointer(Unsize)) -4:17-4:22: @1.Call: _10 = DebugStruct::field(move _11, move _13, move _15) -> [return: bb2, unwind: bb6] +4:17-4:22: @1.Call: _10 = std::fmt::DebugStruct::field(move _11, move _13, move _15) -> [return: bb2, unwind: bb6] 4:17-4:22: @2[11]: _21 = &mut _6 4:17-4:22: @2[12]: _20 = &mut (*_21) 4:17-4:22: @2[15]: _23 = const "minor" @@ -95,7 +95,7 @@ For revisions in Pull Requests (PR): 4:17-4:22: @2[22]: _26 = &_27 4:17-4:22: @2[23]: _25 = &(*_26) 4:17-4:22: @2[24]: _24 = move _25 as &dyn std::fmt::Debug (Pointer(Unsize)) -4:17-4:22: @2.Call: _19 = DebugStruct::field(move _20, move _22, move _24) -> [return: bb3, unwind: bb6] +4:17-4:22: @2.Call: _19 = std::fmt::DebugStruct::field(move _20, move _22, move _24) -> [return: bb3, unwind: bb6] 4:17-4:22: @3[11]: _30 = &mut _6 4:17-4:22: @3[12]: _29 = &mut (*_30) 4:17-4:22: @3[15]: _32 = const "patch" @@ -104,10 +104,10 @@ For revisions in Pull Requests (PR): 4:17-4:22: @3[22]: _35 = &_36 4:17-4:22: @3[23]: _34 = &(*_35) 4:17-4:22: @3[24]: _33 = move _34 as &dyn std::fmt::Debug (Pointer(Unsize)) -4:17-4:22: @3.Call: _28 = DebugStruct::field(move _29, move _31, move _33) -> [return: bb4, unwind: bb6] +4:17-4:22: @3.Call: _28 = std::fmt::DebugStruct::field(move _29, move _31, move _33) -> [return: bb4, unwind: bb6] 4:17-4:22: @4[10]: _38 = &mut _6 4:17-4:22: @4[11]: _37 = &mut (*_38) -4:17-4:22: @4.Call: _0 = DebugStruct::finish(move _37) -> [return: bb5, unwind: bb6] +4:17-4:22: @4.Call: _0 = std::fmt::DebugStruct::finish(move _37) -> [return: bb5, unwind: bb6] 4:22-4:22: @5.Return: return"><span class="annotation">@0,1,2,3,4,5⦊</span>Debug<span class="annotation">⦉@0,1,2,3,4,5</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#8}-clone.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#8}-clone.-------.InstrumentCoverage.0.html index 27a2ab71827..f1c98393343 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#8}-clone.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#8}-clone.-------.InstrumentCoverage.0.html @@ -75,13 +75,13 @@ For revisions in Pull Requests (PR): 4:10-4:15: @0[6]: _4 = &((*_1).2: usize) 4:10-4:15: @0[10]: _7 = &(*_2) 4:10-4:15: @0[11]: _6 = &(*_7) -4:10-4:15: @0.Call: _5 = <usize as Clone>::clone(move _6) -> [return: bb1, unwind: bb4] +4:10-4:15: @0.Call: _5 = <usize as std::clone::Clone>::clone(move _6) -> [return: bb1, unwind: bb4] 4:10-4:15: @1[4]: _10 = &(*_3) 4:10-4:15: @1[5]: _9 = &(*_10) -4:10-4:15: @1.Call: _8 = <usize as Clone>::clone(move _9) -> [return: bb2, unwind: bb4] +4:10-4:15: @1.Call: _8 = <usize as std::clone::Clone>::clone(move _9) -> [return: bb2, unwind: bb4] 4:10-4:15: @2[4]: _13 = &(*_4) 4:10-4:15: @2[5]: _12 = &(*_13) -4:10-4:15: @2.Call: _11 = <usize as Clone>::clone(move _12) -> [return: bb3, unwind: bb4] +4:10-4:15: @2.Call: _11 = <usize as std::clone::Clone>::clone(move _12) -> [return: bb3, unwind: bb4] 4:10-4:15: @3[1]: _0 = Version { major: move _5, minor: move _8, patch: move _11 } 4:15-4:15: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>Clone<span class="annotation">⦉@0,1,2,3</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html index f528b698d44..6b911eea341 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html @@ -69,81 +69,81 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"> let mut countdown = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 12:9-12:16: @3[6]: _7 = _1"> if</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb13] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb13] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb12] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 0_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html index 8e49e45b86e..a56692d9c2a 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html @@ -69,65 +69,65 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<div class="code" style="counter-reset: line 2"><span class="line"><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"> // dependent conditions.</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"></span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 9:9-9:22: @3[3]: FakeRead(ForLet, _5) 10:8-10:15: @3[6]: _7 = _1"> let mut countdown = 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb21] +<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb21] 7:19-7:35: @1[0]: _3 = &_4 -7:19-7:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] +7:19-7:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb20] 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize) 7:9-7:16: @2[3]: FakeRead(ForLet, _1) 9:25-9:26: @3[2]: _5 = const 1_i32 @@ -147,7 +147,7 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> in</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="17:9-17:13: @9[5]: _16 = &mut _10 17:9-17:13: @9[6]: _15 = &mut (*_16) -17:9-17:13: @9.Call: _14 = <std::ops::Range<i32> as Iterator>::next(move _15) -> [return: bb10, unwind: bb21] +17:9-17:13: @9.Call: _14 = <std::ops::Range<i32> as std::iter::Iterator>::next(move _15) -> [return: bb10, unwind: bb21] 17:9-17:13: @10[1]: FakeRead(ForMatchedPlace, _14)"><span class="annotation">@8,9,10⦊</span>0..2<span class="annotation">⦉@8,9,10</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> let z</span></span> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html index 41404759c3d..5b0c5cb072f 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html @@ -84,7 +84,7 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> in</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="19:9-19:14: @3[5]: _11 = &mut _5 19:9-19:14: @3[6]: _10 = &mut (*_11) -19:9-19:14: @3.Call: _9 = <std::ops::Range<i32> as Iterator>::next(move _10) -> [return: bb4, unwind: bb39] +19:9-19:14: @3.Call: _9 = <std::ops::Range<i32> as std::iter::Iterator>::next(move _10) -> [return: bb4, unwind: bb39] 19:9-19:14: @4[1]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@2,3,4⦊</span>0..10<span class="annotation">⦉@2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="21:9-22:17: @8[12]: _17 = CheckedSub(_1, const 1_i32) @@ -110,16 +110,16 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="27:13-27:41: @10.Call: _22 = call(const true) -> [return: bb12, unwind: bb39]"><span class="annotation">@10,12,13⦊</span>call(/*return_error=*/ true)<span class="annotation">⦉@10,12,13</span></span></span><span><span class="code odd" style="--layer: 1" title="27:41-27:42: @17[1]: _24 = ((_21 as Err).0: ()) 27:41-27:42: @17[4]: _27 = _24 -27:41-27:42: @17.Call: _26 = <() as From<()>>::from(move _27) -> [return: bb18, unwind: bb39]"><span class="annotation">@15,17,18,19⦊</span>?<span class="annotation">⦉@15,17,18,19</span></span></span><span class="code" style="--layer: 0">;</span></span> +27:41-27:42: @17.Call: _26 = <() as std::convert::From<()>>::from(move _27) -> [return: bb18, unwind: bb39]"><span class="annotation">@15,17,18,19⦊</span>?<span class="annotation">⦉@15,17,18,19</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="28:13-28:42: @14.Call: _31 = call(const false) -> [return: bb20, unwind: bb39]"><span class="annotation">@14,20,21⦊</span>call(/*return_error=*/ false)<span class="annotation">⦉@14,20,21</span></span></span><span><span class="code odd" style="--layer: 1" title="28:42-28:43: @25[1]: _33 = ((_30 as Err).0: ()) 28:42-28:43: @25[4]: _36 = _33 -28:42-28:43: @25.Call: _35 = <() as From<()>>::from(move _36) -> [return: bb26, unwind: bb39]"><span class="annotation">@23,25,26,27⦊</span>?<span class="annotation">⦉@23,25,26,27</span></span></span><span class="code" style="--layer: 0">;</span></span> +28:42-28:43: @25.Call: _35 = <() as std::convert::From<()>>::from(move _36) -> [return: bb26, unwind: bb39]"><span class="annotation">@23,25,26,27⦊</span>?<span class="annotation">⦉@23,25,26,27</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> else</span></span> <span class="line"><span class="code" style="--layer: 0"> {</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="32:13-32:42: @11.Call: _40 = call(const false) -> [return: bb28, unwind: bb39]"><span class="annotation">@11,28,29⦊</span>call(/*return_error=*/ false)<span class="annotation">⦉@11,28,29</span></span></span><span><span class="code odd" style="--layer: 1" title="32:42-32:43: @33[1]: _42 = ((_39 as Err).0: ()) 32:42-32:43: @33[4]: _45 = _42 -32:42-32:43: @33.Call: _44 = <() as From<()>>::from(move _45) -> [return: bb34, unwind: bb39]"><span class="annotation">@31,33,34,35⦊</span>?<span class="annotation">⦉@31,33,34,35</span></span></span><span class="code" style="--layer: 0">;</span></span> +32:42-32:43: @33.Call: _44 = <() as std::convert::From<()>>::from(move _45) -> [return: bb34, unwind: bb39]"><span class="annotation">@31,33,34,35⦊</span>?<span class="annotation">⦉@31,33,34,35</span></span></span><span class="code" style="--layer: 0">;</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="35:8-35:10: @5[9]: _47 = () diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html index 4af7b179866..65e21ecef13 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html @@ -69,36 +69,36 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 36"><span class="line"><span><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<div class="code" style="counter-reset: line 36"><span class="line"><span><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 38:19-38:35: @1[0]: _3 = &_4 -38:19-38:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +38:19-38:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize) 38:9-38:16: @2[3]: FakeRead(ForLet, _1) 39:25-39:26: @3[2]: _5 = const 2_i32 39:9-39:22: @3[3]: FakeRead(ForLet, _5) 40:9-40:16: @3[6]: _7 = _1 40:8-40:16: @3[7]: _6 = Not(move _7)"><span class="annotation">@0,1,2,3⦊</span>pub fn unused_function() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 38:19-38:35: @1[0]: _3 = &_4 -38:19-38:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +38:19-38:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize) 38:9-38:16: @2[3]: FakeRead(ForLet, _1) 39:25-39:26: @3[2]: _5 = const 2_i32 39:9-39:22: @3[3]: FakeRead(ForLet, _5) 40:9-40:16: @3[6]: _7 = _1 40:8-40:16: @3[7]: _6 = Not(move _7)"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 38:19-38:35: @1[0]: _3 = &_4 -38:19-38:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +38:19-38:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize) 38:9-38:16: @2[3]: FakeRead(ForLet, _1) 39:25-39:26: @3[2]: _5 = const 2_i32 39:9-39:22: @3[3]: FakeRead(ForLet, _5) 40:9-40:16: @3[6]: _7 = _1 40:8-40:16: @3[7]: _6 = Not(move _7)"> let mut countdown = 2;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 38:19-38:35: @1[0]: _3 = &_4 -38:19-38:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +38:19-38:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize) 38:9-38:16: @2[3]: FakeRead(ForLet, _1) 39:25-39:26: @3[2]: _5 = const 2_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html index 6b0ce85c460..02154a2268b 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html @@ -78,14 +78,14 @@ For revisions in Pull Requests (PR): 34:5-34:56: @0[20]: FakeRead(ForMatchedPlace, _13) 34:5-34:56: @0[22]: _15 = (_13.0: &T) 34:5-34:56: @0[25]: _17 = &(*_15) -34:5-34:56: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -34:5-34:56: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +34:5-34:56: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +34:5-34:56: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 34:5-34:56: @1[2]: _12 = [move _16] 34:5-34:56: @1[5]: _11 = &_12 34:5-34:56: @1[6]: _10 = &(*_11) 34:5-34:56: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -34:5-34:56: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -34:5-34:56: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +34:5-34:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +34:5-34:56: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 34:5-34:56: @3[6]: _2 = const () 33:50-35:2: @3[8]: _0 = const () 35:2-35:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn unused_generic_function<T: Debug>(arg: T) {</span></span> @@ -98,14 +98,14 @@ For revisions in Pull Requests (PR): 34:5-34:56: @0[20]: FakeRead(ForMatchedPlace, _13) 34:5-34:56: @0[22]: _15 = (_13.0: &T) 34:5-34:56: @0[25]: _17 = &(*_15) -34:5-34:56: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -34:5-34:56: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +34:5-34:56: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +34:5-34:56: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 34:5-34:56: @1[2]: _12 = [move _16] 34:5-34:56: @1[5]: _11 = &_12 34:5-34:56: @1[6]: _10 = &(*_11) 34:5-34:56: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -34:5-34:56: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -34:5-34:56: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +34:5-34:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +34:5-34:56: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 34:5-34:56: @3[6]: _2 = const () 33:50-35:2: @3[8]: _0 = const () 35:2-35:2: @4.Return: return"> println!("unused_generic_function with {:?}", arg);</span></span> @@ -118,14 +118,14 @@ For revisions in Pull Requests (PR): 34:5-34:56: @0[20]: FakeRead(ForMatchedPlace, _13) 34:5-34:56: @0[22]: _15 = (_13.0: &T) 34:5-34:56: @0[25]: _17 = &(*_15) -34:5-34:56: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -34:5-34:56: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +34:5-34:56: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +34:5-34:56: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 34:5-34:56: @1[2]: _12 = [move _16] 34:5-34:56: @1[5]: _11 = &_12 34:5-34:56: @1[6]: _10 = &(*_11) 34:5-34:56: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -34:5-34:56: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -34:5-34:56: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +34:5-34:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +34:5-34:56: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 34:5-34:56: @3[6]: _2 = const () 33:50-35:2: @3[8]: _0 = const () 35:2-35:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html index 6424e03fc71..78228594e37 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html @@ -69,36 +69,36 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 44"><span class="line"><span><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<div class="code" style="counter-reset: line 44"><span class="line"><span><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 46:19-46:35: @1[0]: _3 = &_4 -46:19-46:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +46:19-46:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize) 46:9-46:16: @2[3]: FakeRead(ForLet, _1) 47:25-47:26: @3[2]: _5 = const 2_i32 47:9-47:22: @3[3]: FakeRead(ForLet, _5) 48:9-48:16: @3[6]: _7 = _1 48:8-48:16: @3[7]: _6 = Not(move _7)"><span class="annotation">@0,1,2,3⦊</span>fn unused_private_function() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 46:19-46:35: @1[0]: _3 = &_4 -46:19-46:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +46:19-46:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize) 46:9-46:16: @2[3]: FakeRead(ForLet, _1) 47:25-47:26: @3[2]: _5 = const 2_i32 47:9-47:22: @3[3]: FakeRead(ForLet, _5) 48:9-48:16: @3[6]: _7 = _1 48:8-48:16: @3[7]: _6 = Not(move _7)"> let is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 46:19-46:35: @1[0]: _3 = &_4 -46:19-46:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +46:19-46:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize) 46:9-46:16: @2[3]: FakeRead(ForLet, _1) 47:25-47:26: @3[2]: _5 = const 2_i32 47:9-47:22: @3[3]: FakeRead(ForLet, _5) 48:9-48:16: @3[6]: _7 = _1 48:8-48:16: @3[7]: _6 = Not(move _7)"> let mut countdown = 2;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb8] +<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb8] 46:19-46:35: @1[0]: _3 = &_4 -46:19-46:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] +46:19-46:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb7] 46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize) 46:9-46:16: @2[3]: FakeRead(ForLet, _1) 47:25-47:26: @3[2]: _5 = const 2_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html index 7c44c536379..8f618d2e249 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html @@ -69,122 +69,122 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 52"><span class="line"><span><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +<div class="code" style="counter-reset: line 52"><span class="line"><span><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7⦊</span>fn use_this_lib_crate() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>fn use_this_lib_crate() {</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"> used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs");</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"> used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs");</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"> used_with_same_type_from_bin_crate_and_lib_crate_generic_function(</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"> used_with_same_type_from_bin_crate_and_lib_crate_generic_function(</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"> "used from library used_crate.rs",</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"> "used from library used_crate.rs",</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"> );</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"> );</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"> let some_vec = vec![5, 6, 7, 8];</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"> let some_vec = vec![5, 6, 7, 8];</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"> used_only_from_this_lib_crate_generic_function(some_vec);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"> used_only_from_this_lib_crate_generic_function(some_vec);</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return"> used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs");</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb10] -55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb10] +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return"> used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs");</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb1, unwind: bb13] +55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "used from library used_crate.rs") -> [return: bb2, unwind: bb13] 58:20-58:36: @2[5]: _6 = Box([i32; 4]) 58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32] 58:20-58:36: @2[7]: _5 = move _6 58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box<[i32]> (Pointer(Unsize)) -58:20-58:36: @3.Call: _3 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb4, unwind: bb10] -58:9-58:17: @4[1]: FakeRead(ForLet, _3) -59:52-59:60: @4[4]: _8 = move _3 -59:5-59:61: @4.Call: _7 = used_only_from_this_lib_crate_generic_function::<Vec<i32>>(move _8) -> [return: bb5, unwind: bb8] -60:5-60:91: @5.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb6, unwind: bb8] -53:25-61:2: @6[1]: _0 = const () -61:2-61:2: @7.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7</span></span></span></span></div> +58:20-58:36: @4.Call: _3 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _4) -> [return: bb5, unwind: bb12] +58:9-58:17: @5[1]: FakeRead(ForLet, _3) +59:52-59:60: @5[4]: _8 = move _3 +59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::<std::vec::Vec<i32>>(move _8) -> [return: bb6, unwind: bb9] +60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::<&str>(const "used ONLY from library used_crate.rs") -> [return: bb7, unwind: bb10] +53:25-61:2: @7[1]: _0 = const () +61:2-61:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html index 8b994a6962b..61a709c4729 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html @@ -78,14 +78,14 @@ For revisions in Pull Requests (PR): 26:5-26:83: @0[20]: FakeRead(ForMatchedPlace, _13) 26:5-26:83: @0[22]: _15 = (_13.0: &T) 26:5-26:83: @0[25]: _17 = &(*_15) -26:5-26:83: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -26:5-26:83: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +26:5-26:83: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +26:5-26:83: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 26:5-26:83: @1[2]: _12 = [move _16] 26:5-26:83: @1[5]: _11 = &_12 26:5-26:83: @1[6]: _10 = &(*_11) 26:5-26:83: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -26:5-26:83: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -26:5-26:83: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +26:5-26:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +26:5-26:83: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 26:5-26:83: @3[6]: _2 = const () 25:77-27:2: @3[8]: _0 = const () 27:2-27:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {</span></span> @@ -98,14 +98,14 @@ For revisions in Pull Requests (PR): 26:5-26:83: @0[20]: FakeRead(ForMatchedPlace, _13) 26:5-26:83: @0[22]: _15 = (_13.0: &T) 26:5-26:83: @0[25]: _17 = &(*_15) -26:5-26:83: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -26:5-26:83: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +26:5-26:83: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +26:5-26:83: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 26:5-26:83: @1[2]: _12 = [move _16] 26:5-26:83: @1[5]: _11 = &_12 26:5-26:83: @1[6]: _10 = &(*_11) 26:5-26:83: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -26:5-26:83: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -26:5-26:83: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +26:5-26:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +26:5-26:83: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 26:5-26:83: @3[6]: _2 = const () 25:77-27:2: @3[8]: _0 = const () 27:2-27:2: @4.Return: return"> println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);</span></span> @@ -118,14 +118,14 @@ For revisions in Pull Requests (PR): 26:5-26:83: @0[20]: FakeRead(ForMatchedPlace, _13) 26:5-26:83: @0[22]: _15 = (_13.0: &T) 26:5-26:83: @0[25]: _17 = &(*_15) -26:5-26:83: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -26:5-26:83: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +26:5-26:83: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +26:5-26:83: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 26:5-26:83: @1[2]: _12 = [move _16] 26:5-26:83: @1[5]: _11 = &_12 26:5-26:83: @1[6]: _10 = &(*_11) 26:5-26:83: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -26:5-26:83: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -26:5-26:83: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +26:5-26:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +26:5-26:83: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 26:5-26:83: @3[6]: _2 = const () 25:77-27:2: @3[8]: _0 = const () 27:2-27:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html index d35f191b64e..974a24b2c6d 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html @@ -73,25 +73,25 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span> <span class="line"><span class="code" style="--layer: 0"> // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span> <span class="line"><span class="code" style="--layer: 0"> // dependent conditions.</span></span> -<span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code even" style="--layer: 1" title="9:19-9:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb9] +<span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code even" style="--layer: 1" title="9:19-9:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb9] 9:19-9:35: @1[0]: _3 = &_4 -9:19-9:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb8] +9:19-9:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb8] 9:19-9:46: @2[1]: _1 = Eq(move _2, const 1_usize) 9:9-9:16: @2[3]: FakeRead(ForLet, _1) 10:25-10:26: @3[2]: _5 = const 0_i32 10:9-10:22: @3[3]: FakeRead(ForLet, _5) 11:8-11:15: @3[6]: _7 = _1"><span class="annotation">@0,1,2,3⦊</span>is_true = std::env::args().len() == 1;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="9:19-9:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb9] +<span class="line"><span class="code even" style="--layer: 1" title="9:19-9:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb9] 9:19-9:35: @1[0]: _3 = &_4 -9:19-9:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb8] +9:19-9:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb8] 9:19-9:46: @2[1]: _1 = Eq(move _2, const 1_usize) 9:9-9:16: @2[3]: FakeRead(ForLet, _1) 10:25-10:26: @3[2]: _5 = const 0_i32 10:9-10:22: @3[3]: FakeRead(ForLet, _5) 11:8-11:15: @3[6]: _7 = _1"> let mut countdown = 0;</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="9:19-9:35: @0.Call: _4 = args() -> [return: bb1, unwind: bb9] +<span class="line"><span class="code even" style="--layer: 1" title="9:19-9:35: @0.Call: _4 = std::env::args() -> [return: bb1, unwind: bb9] 9:19-9:35: @1[0]: _3 = &_4 -9:19-9:41: @1.Call: _2 = <Args as ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb8] +9:19-9:41: @1.Call: _2 = <std::env::Args as std::iter::ExactSizeIterator>::len(move _3) -> [return: bb2, unwind: bb8] 9:19-9:46: @2[1]: _1 = Eq(move _2, const 1_usize) 9:9-9:16: @2[3]: FakeRead(ForLet, _1) 10:25-10:26: @3[2]: _5 = const 0_i32 diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html index 29fe03382c7..68035339fe4 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html @@ -78,14 +78,14 @@ For revisions in Pull Requests (PR): 18:5-18:74: @0[20]: FakeRead(ForMatchedPlace, _13) 18:5-18:74: @0[22]: _15 = (_13.0: &T) 18:5-18:74: @0[25]: _17 = &(*_15) -18:5-18:74: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -18:5-18:74: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +18:5-18:74: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +18:5-18:74: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 18:5-18:74: @1[2]: _12 = [move _16] 18:5-18:74: @1[5]: _11 = &_12 18:5-18:74: @1[6]: _10 = &(*_11) 18:5-18:74: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -18:5-18:74: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -18:5-18:74: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +18:5-18:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +18:5-18:74: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 18:5-18:74: @3[6]: _2 = const () 17:68-19:2: @3[8]: _0 = const () 19:2-19:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) {</span></span> @@ -98,14 +98,14 @@ For revisions in Pull Requests (PR): 18:5-18:74: @0[20]: FakeRead(ForMatchedPlace, _13) 18:5-18:74: @0[22]: _15 = (_13.0: &T) 18:5-18:74: @0[25]: _17 = &(*_15) -18:5-18:74: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -18:5-18:74: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +18:5-18:74: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +18:5-18:74: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 18:5-18:74: @1[2]: _12 = [move _16] 18:5-18:74: @1[5]: _11 = &_12 18:5-18:74: @1[6]: _10 = &(*_11) 18:5-18:74: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -18:5-18:74: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -18:5-18:74: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +18:5-18:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +18:5-18:74: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 18:5-18:74: @3[6]: _2 = const () 17:68-19:2: @3[8]: _0 = const () 19:2-19:2: @4.Return: return"> println!("used_only_from_bin_crate_generic_function with {:?}", arg);</span></span> @@ -118,14 +118,14 @@ For revisions in Pull Requests (PR): 18:5-18:74: @0[20]: FakeRead(ForMatchedPlace, _13) 18:5-18:74: @0[22]: _15 = (_13.0: &T) 18:5-18:74: @0[25]: _17 = &(*_15) -18:5-18:74: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -18:5-18:74: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +18:5-18:74: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +18:5-18:74: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 18:5-18:74: @1[2]: _12 = [move _16] 18:5-18:74: @1[5]: _11 = &_12 18:5-18:74: @1[6]: _10 = &(*_11) 18:5-18:74: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -18:5-18:74: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -18:5-18:74: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +18:5-18:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +18:5-18:74: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 18:5-18:74: @3[6]: _2 = const () 17:68-19:2: @3[8]: _0 = const () 19:2-19:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html index 76bc057dd00..63944eb9ab3 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html @@ -78,14 +78,14 @@ For revisions in Pull Requests (PR): 22:5-22:79: @0[20]: FakeRead(ForMatchedPlace, _13) 22:5-22:79: @0[22]: _15 = (_13.0: &T) 22:5-22:79: @0[25]: _17 = &(*_15) -22:5-22:79: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -22:5-22:79: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +22:5-22:79: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +22:5-22:79: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 22:5-22:79: @1[2]: _12 = [move _16] 22:5-22:79: @1[5]: _11 = &_12 22:5-22:79: @1[6]: _10 = &(*_11) 22:5-22:79: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -22:5-22:79: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -22:5-22:79: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +22:5-22:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +22:5-22:79: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 22:5-22:79: @3[6]: _2 = const () 21:73-23:2: @3[8]: _0 = const () 23:2-23:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_only_from_this_lib_crate_generic_function<T: Debug>(arg: T) {</span></span> @@ -98,14 +98,14 @@ For revisions in Pull Requests (PR): 22:5-22:79: @0[20]: FakeRead(ForMatchedPlace, _13) 22:5-22:79: @0[22]: _15 = (_13.0: &T) 22:5-22:79: @0[25]: _17 = &(*_15) -22:5-22:79: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -22:5-22:79: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +22:5-22:79: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +22:5-22:79: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 22:5-22:79: @1[2]: _12 = [move _16] 22:5-22:79: @1[5]: _11 = &_12 22:5-22:79: @1[6]: _10 = &(*_11) 22:5-22:79: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -22:5-22:79: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -22:5-22:79: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +22:5-22:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +22:5-22:79: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 22:5-22:79: @3[6]: _2 = const () 21:73-23:2: @3[8]: _0 = const () 23:2-23:2: @4.Return: return"> println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);</span></span> @@ -118,14 +118,14 @@ For revisions in Pull Requests (PR): 22:5-22:79: @0[20]: FakeRead(ForMatchedPlace, _13) 22:5-22:79: @0[22]: _15 = (_13.0: &T) 22:5-22:79: @0[25]: _17 = &(*_15) -22:5-22:79: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -22:5-22:79: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +22:5-22:79: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +22:5-22:79: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 22:5-22:79: @1[2]: _12 = [move _16] 22:5-22:79: @1[5]: _11 = &_12 22:5-22:79: @1[6]: _10 = &(*_11) 22:5-22:79: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -22:5-22:79: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -22:5-22:79: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +22:5-22:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +22:5-22:79: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 22:5-22:79: @3[6]: _2 = const () 21:73-23:2: @3[8]: _0 = const () 23:2-23:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html index a2f4b7e19eb..b146180fbd1 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html @@ -78,14 +78,14 @@ For revisions in Pull Requests (PR): 30:5-30:98: @0[20]: FakeRead(ForMatchedPlace, _13) 30:5-30:98: @0[22]: _15 = (_13.0: &T) 30:5-30:98: @0[25]: _17 = &(*_15) -30:5-30:98: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -30:5-30:98: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +30:5-30:98: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +30:5-30:98: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 30:5-30:98: @1[2]: _12 = [move _16] 30:5-30:98: @1[5]: _11 = &_12 30:5-30:98: @1[6]: _10 = &(*_11) 30:5-30:98: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -30:5-30:98: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -30:5-30:98: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +30:5-30:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +30:5-30:98: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 30:5-30:98: @3[6]: _2 = const () 29:92-31:2: @3[8]: _0 = const () 31:2-31:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {</span></span> @@ -98,14 +98,14 @@ For revisions in Pull Requests (PR): 30:5-30:98: @0[20]: FakeRead(ForMatchedPlace, _13) 30:5-30:98: @0[22]: _15 = (_13.0: &T) 30:5-30:98: @0[25]: _17 = &(*_15) -30:5-30:98: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -30:5-30:98: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +30:5-30:98: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +30:5-30:98: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 30:5-30:98: @1[2]: _12 = [move _16] 30:5-30:98: @1[5]: _11 = &_12 30:5-30:98: @1[6]: _10 = &(*_11) 30:5-30:98: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -30:5-30:98: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -30:5-30:98: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +30:5-30:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +30:5-30:98: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 30:5-30:98: @3[6]: _2 = const () 29:92-31:2: @3[8]: _0 = const () 31:2-31:2: @4.Return: return"> println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);</span></span> @@ -118,14 +118,14 @@ For revisions in Pull Requests (PR): 30:5-30:98: @0[20]: FakeRead(ForMatchedPlace, _13) 30:5-30:98: @0[22]: _15 = (_13.0: &T) 30:5-30:98: @0[25]: _17 = &(*_15) -30:5-30:98: @0[27]: _18 = <T as Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) -30:5-30:98: @0.Call: _16 = ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] +30:5-30:98: @0[27]: _18 = <T as std::fmt::Debug>::fmt as for<'r, 's, 't0> fn(&'r T, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)) +30:5-30:98: @0.Call: _16 = std::fmt::ArgumentV1::new::<T>(move _17, move _18) -> [return: bb1, unwind: bb5] 30:5-30:98: @1[2]: _12 = [move _16] 30:5-30:98: @1[5]: _11 = &_12 30:5-30:98: @1[6]: _10 = &(*_11) 30:5-30:98: @1[7]: _9 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)) -30:5-30:98: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] -30:5-30:98: @2.Call: _3 = _print(move _4) -> [return: bb3, unwind: bb5] +30:5-30:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -> [return: bb2, unwind: bb5] +30:5-30:98: @2.Call: _3 = std::io::_print(move _4) -> [return: bb3, unwind: bb5] 30:5-30:98: @3[6]: _2 = const () 29:92-31:2: @3[8]: _0 = const () 31:2-31:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html index ba6af60fa5c..28cf051ecf8 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html @@ -69,125 +69,125 @@ For revisions in Pull Requests (PR): </style> </head> <body> -<div class="code" style="counter-reset: line 4"><span class="line"><span><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +<div class="code" style="counter-reset: line 4"><span class="line"><span><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>fn main() {</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9⦊</span>fn main() {</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return"> used_crate::used_function();</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return"> used_crate::used_function();</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return"> let some_vec = vec![1, 2, 3, 4];</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return"> let some_vec = vec![1, 2, 3, 4];</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return"> used_crate::used_only_from_bin_crate_generic_function(&some_vec);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return"> used_crate::used_only_from_bin_crate_generic_function(&some_vec);</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return"> used_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs");</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return"> used_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs");</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return"> used_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec);</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return"> used_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec);</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return"> used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function("interesting?");</span></span> -<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_function() -> [return: bb1, unwind: bb11] +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return"> used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function("interesting?");</span></span> +<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -> [return: bb1, unwind: bb14] 7:20-7:36: @1[5]: _5 = Box([i32; 4]) 7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32] 7:20-7:36: @1[7]: _4 = move _5 7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box<[i32]> (Pointer(Unsize)) -7:20-7:36: @2.Call: _2 = slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb3, unwind: bb11] -7:9-7:17: @3[1]: FakeRead(ForLet, _2) -8:59-8:68: @3[4]: _7 = &_2 -8:5-8:69: @3.Call: _6 = used_only_from_bin_crate_generic_function::<&Vec<i32>>(move _7) -> [return: bb4, unwind: bb9] -9:5-9:89: @4.Call: _8 = used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb5, unwind: bb9] -10:68-10:76: @5[3]: _10 = move _2 -10:5-10:77: @5.Call: _9 = used_from_bin_crate_and_lib_crate_generic_function::<Vec<i32>>(move _10) -> [return: bb6, unwind: bb9] -11:5-11:98: @6.Call: _11 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb7, unwind: bb9] -5:11-12:2: @7[1]: _0 = const () -12:2-12:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div> +7:20-7:36: @3.Call: _2 = std::slice::<impl [i32]>::into_vec::<std::alloc::Global>(move _3) -> [return: bb4, unwind: bb13] +7:9-7:17: @4[1]: FakeRead(ForLet, _2) +8:59-8:68: @4[4]: _7 = &_2 +8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::<&std::vec::Vec<i32>>(move _7) -> [return: bb5, unwind: bb11] +9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::<&str>(const "used from bin uses_crate.rs") -> [return: bb6, unwind: bb11] +10:68-10:76: @6[3]: _10 = move _2 +10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::<std::vec::Vec<i32>>(move _10) -> [return: bb7, unwind: bb10] +11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>(const "interesting?") -> [return: bb8, unwind: bb11] +5:11-12:2: @8[1]: _0 = const () +12:2-12:2: @9.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9</span></span></span></span></div> </body> </html> diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html index 99e56393ea5..4c0c0d562b8 100644 --- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html @@ -76,26 +76,26 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> };</span></span> <span class="line"><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> match </span><span><span class="code even" style="--layer: 1" title="13:20-13:34: @0[7]: _5 = &mut _1 -13:11-13:35: @0.Call: _4 = Pin::<&mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]>::new(move _5) -> [return: bb1, unwind: bb26] +13:11-13:35: @0.Call: _4 = std::pin::Pin::<&mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]>::new(move _5) -> [return: bb1, unwind: bb26] 13:43-13:45: @1[2]: _6 = () -13:11-13:46: @1.Call: _3 = <[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as Generator>::resume(move _4, move _6) -> [return: bb2, unwind: bb26] +13:11-13:46: @1.Call: _3 = <[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as std::ops::Generator>::resume(move _4, move _6) -> [return: bb2, unwind: bb26] 13:11-13:46: @2[2]: FakeRead(ForMatchedPlace, _3) 14:9-14:35: @2[3]: _7 = discriminant(_3)"><span class="annotation">@0,1,2⦊</span>Pin::new(&mut generator).resume(()) {</span></span> <span class="line"><span class="code even" style="--layer: 1" title="13:20-13:34: @0[7]: _5 = &mut _1 -13:11-13:35: @0.Call: _4 = Pin::<&mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]>::new(move _5) -> [return: bb1, unwind: bb26] +13:11-13:35: @0.Call: _4 = std::pin::Pin::<&mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]>::new(move _5) -> [return: bb1, unwind: bb26] 13:43-13:45: @1[2]: _6 = () -13:11-13:46: @1.Call: _3 = <[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as Generator>::resume(move _4, move _6) -> [return: bb2, unwind: bb26] +13:11-13:46: @1.Call: _3 = <[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as std::ops::Generator>::resume(move _4, move _6) -> [return: bb2, unwind: bb26] 13:11-13:46: @2[2]: FakeRead(ForMatchedPlace, _3) 14:9-14:35: @2[3]: _7 = discriminant(_3)"> GeneratorState::Yielded(1)<span class="annotation">⦉@0,1,2</span></span></span><span class="code" style="--layer: 0"> => </span><span><span class="code odd" style="--layer: 1" title="14:39-14:41: @6[0]: _2 = const ()"><span class="annotation">@4,6,7,8⦊</span>{}<span class="annotation">⦉@4,6,7,8</span></span></span><span class="code" style="--layer: 0"></span></span> -<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code even" style="--layer: 1" title="15:14-15:52: @5.Call: begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@5⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0">,</span></span> +<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code even" style="--layer: 1" title="15:14-15:52: @5.Call: std::rt::begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@5⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0">,</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> match </span><span><span class="code odd" style="--layer: 1" title="17:20-17:34: @6[7]: _12 = &mut _1 -17:11-17:35: @6.Call: _11 = Pin::<&mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]>::new(move _12) -> [return: bb7, unwind: bb26] +17:11-17:35: @6.Call: _11 = std::pin::Pin::<&mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]>::new(move _12) -> [return: bb7, unwind: bb26] 17:43-17:45: @7[2]: _13 = () -17:11-17:46: @7.Call: _10 = <[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as Generator>::resume(move _11, move _13) -> [return: bb8, unwind: bb26] +17:11-17:46: @7.Call: _10 = <[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as std::ops::Generator>::resume(move _11, move _13) -> [return: bb8, unwind: bb26] 17:11-17:46: @8[2]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@4,6,7,8⦊</span>Pin::new(&mut generator).resume(())<span class="annotation">⦉@4,6,7,8</span></span></span><span class="code" style="--layer: 0"> {</span></span> -<span class="line"><span class="code" style="--layer: 0"> GeneratorState::Complete(</span><span><span class="code even" style="--layer: 1" title="18:34-18:39: @10.Call: _14 = <str as PartialEq>::eq(((_10 as Complete).0: &str), const "foo") -> [return: bb11, unwind: bb26]"><span class="annotation">@10,11⦊</span>"foo"<span class="annotation">⦉@10,11</span></span></span><span class="code" style="--layer: 0">) => </span><span><span class="code odd" style="--layer: 1" title="18:44-18:46: @13[0]: _9 = const ()"><span class="annotation">@12,13,14,15⦊</span>{}<span class="annotation">⦉@12,13,14,15</span></span></span><span class="code" style="--layer: 0"></span></span> -<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code even" style="--layer: 1" title="19:14-19:52: @9.Call: begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@9⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0">,</span></span> +<span class="line"><span class="code" style="--layer: 0"> GeneratorState::Complete(</span><span><span class="code even" style="--layer: 1" title="18:34-18:39: @10.Call: _14 = <str as std::cmp::PartialEq>::eq(((_10 as Complete).0: &str), const "foo") -> [return: bb11, unwind: bb26]"><span class="annotation">@10,11⦊</span>"foo"<span class="annotation">⦉@10,11</span></span></span><span class="code" style="--layer: 0">) => </span><span><span class="code odd" style="--layer: 1" title="18:44-18:46: @13[0]: _9 = const ()"><span class="annotation">@12,13,14,15⦊</span>{}<span class="annotation">⦉@12,13,14,15</span></span></span><span class="code" style="--layer: 0"></span></span> +<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code even" style="--layer: 1" title="19:14-19:52: @9.Call: std::rt::begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@9⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0">,</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> let </span><span><span class="code odd" style="--layer: 1" title="22:9-22:22: @13[5]: FakeRead(ForLet, _17)"><span class="annotation">@12,13,14,15⦊</span>mut generator<span class="annotation">⦉@12,13,14,15</span></span></span><span class="code" style="--layer: 0"> = || {</span></span> @@ -106,32 +106,32 @@ For revisions in Pull Requests (PR): <span class="line"><span class="code" style="--layer: 0"> };</span></span> <span class="line"><span class="code" style="--layer: 0"></span></span> <span class="line"><span class="code" style="--layer: 0"> match </span><span><span class="code odd" style="--layer: 1" title="29:20-29:34: @13[10]: _21 = &mut _17 -29:11-29:35: @13.Call: _20 = Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _21) -> [return: bb14, unwind: bb26] +29:11-29:35: @13.Call: _20 = std::pin::Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _21) -> [return: bb14, unwind: bb26] 29:43-29:45: @14[2]: _22 = () -29:11-29:46: @14.Call: _19 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as Generator>::resume(move _20, move _22) -> [return: bb15, unwind: bb26] +29:11-29:46: @14.Call: _19 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator>::resume(move _20, move _22) -> [return: bb15, unwind: bb26] 29:11-29:46: @15[2]: FakeRead(ForMatchedPlace, _19) 30:9-30:35: @15[3]: _23 = discriminant(_19)"><span class="annotation">@12,13,14,15⦊</span>Pin::new(&mut generator).resume(()) {</span></span> <span class="line"><span class="code odd" style="--layer: 1" title="29:20-29:34: @13[10]: _21 = &mut _17 -29:11-29:35: @13.Call: _20 = Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _21) -> [return: bb14, unwind: bb26] +29:11-29:35: @13.Call: _20 = std::pin::Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _21) -> [return: bb14, unwind: bb26] 29:43-29:45: @14[2]: _22 = () -29:11-29:46: @14.Call: _19 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as Generator>::resume(move _20, move _22) -> [return: bb15, unwind: bb26] +29:11-29:46: @14.Call: _19 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator>::resume(move _20, move _22) -> [return: bb15, unwind: bb26] 29:11-29:46: @15[2]: FakeRead(ForMatchedPlace, _19) 30:9-30:35: @15[3]: _23 = discriminant(_19)"> GeneratorState::Yielded(1)<span class="annotation">⦉@12,13,14,15</span></span></span><span class="code" style="--layer: 0"> => </span><span><span class="code even" style="--layer: 1" title="30:39-30:41: @19[0]: _18 = const ()"><span class="annotation">@17,19,20,21⦊</span>{}<span class="annotation">⦉@17,19,20,21</span></span></span><span class="code" style="--layer: 0"></span></span> -<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code odd" style="--layer: 1" title="31:14-31:52: @18.Call: begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@18⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0">,</span></span> +<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code odd" style="--layer: 1" title="31:14-31:52: @18.Call: std::rt::begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@18⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0">,</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0"> match </span><span><span class="code even" style="--layer: 1" title="33:20-33:34: @19[6]: _27 = &mut _17 -33:11-33:35: @19.Call: _26 = Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _27) -> [return: bb20, unwind: bb26] +33:11-33:35: @19.Call: _26 = std::pin::Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _27) -> [return: bb20, unwind: bb26] 33:43-33:45: @20[2]: _28 = () -33:11-33:46: @20.Call: _25 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as Generator>::resume(move _26, move _28) -> [return: bb21, unwind: bb26] +33:11-33:46: @20.Call: _25 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator>::resume(move _26, move _28) -> [return: bb21, unwind: bb26] 33:11-33:46: @21[2]: FakeRead(ForMatchedPlace, _25) 34:9-34:35: @21[3]: _29 = discriminant(_25)"><span class="annotation">@17,19,20,21⦊</span>Pin::new(&mut generator).resume(()) {</span></span> <span class="line"><span class="code even" style="--layer: 1" title="33:20-33:34: @19[6]: _27 = &mut _17 -33:11-33:35: @19.Call: _26 = Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _27) -> [return: bb20, unwind: bb26] +33:11-33:35: @19.Call: _26 = std::pin::Pin::<&mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]>::new(move _27) -> [return: bb20, unwind: bb26] 33:43-33:45: @20[2]: _28 = () -33:11-33:46: @20.Call: _25 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as Generator>::resume(move _26, move _28) -> [return: bb21, unwind: bb26] +33:11-33:46: @20.Call: _25 = <[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator>::resume(move _26, move _28) -> [return: bb21, unwind: bb26] 33:11-33:46: @21[2]: FakeRead(ForMatchedPlace, _25) 34:9-34:35: @21[3]: _29 = discriminant(_25)"> GeneratorState::Yielded(2)<span class="annotation">⦉@17,19,20,21</span></span></span><span class="code" style="--layer: 0"> => </span><span><span class="code odd" style="--layer: 1" title="34:39-34:41: @25[0]: _0 = const ()"><span class="annotation">@23,25⦊</span>{}<span class="annotation">⦉@23,25</span></span></span><span class="code" style="--layer: 0"></span></span> -<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code even" style="--layer: 1" title="35:14-35:52: @24.Call: begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@24⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0">,</span></span> +<span class="line"><span class="code" style="--layer: 0"> _ => </span><span><span class="code even" style="--layer: 1" title="35:14-35:52: @24.Call: std::rt::begin_panic::<&str>(const "unexpected value from resume") -> bb26"><span class="annotation">@24⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0">,</span></span> <span class="line"><span class="code" style="--layer: 0"> }</span></span> <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="37:2-37:2: @25.Return: return"><span class="annotation">@23,25⦊</span>‸<span class="annotation">⦉@23,25</span></span></span></span></div> </body> diff --git a/src/test/run-make-fulldeps/coverage/coverage_tools.mk b/src/test/run-make-fulldeps/coverage/coverage_tools.mk index 4d340d4b1da..11fd824e527 100644 --- a/src/test/run-make-fulldeps/coverage/coverage_tools.mk +++ b/src/test/run-make-fulldeps/coverage/coverage_tools.mk @@ -14,10 +14,3 @@ # Therefore, `-C link-dead-code` is no longer automatically enabled. UNAME = $(shell uname) - -# Rust option `-Z instrument-coverage` uses LLVM Coverage Mapping Format version 4, -# which requires LLVM 11 or greater. -LLVM_VERSION_11_PLUS := $(shell \ - LLVM_VERSION=$$("$(LLVM_BIN_DIR)"/llvm-config --version) && \ - LLVM_VERSION_MAJOR=$${LLVM_VERSION/.*/} && \ - [ $$LLVM_VERSION_MAJOR -ge 11 ] && echo true || echo false) diff --git a/src/test/run-make-fulldeps/simd-ffi/simd.rs b/src/test/run-make-fulldeps/simd-ffi/simd.rs index 717da367fee..d11cfd77c5b 100644 --- a/src/test/run-make-fulldeps/simd-ffi/simd.rs +++ b/src/test/run-make-fulldeps/simd-ffi/simd.rs @@ -75,3 +75,8 @@ auto trait Freeze {} macro_rules! Copy { () => {}; } +#[macro_export] +#[rustc_builtin_macro] +macro_rules! derive { + () => {}; +} diff --git a/src/test/run-make-fulldeps/treat-err-as-bug/Makefile b/src/test/run-make-fulldeps/treat-err-as-bug/Makefile deleted file mode 100644 index 57cac76aec2..00000000000 --- a/src/test/run-make-fulldeps/treat-err-as-bug/Makefile +++ /dev/null @@ -1,7 +0,0 @@ --include ../tools.mk - -all: - $(RUSTC) err.rs -Z treat-err-as-bug 2>&1 \ - | $(CGREP) "panicked at 'aborting due to \`-Z treat-err-as-bug=1\`'" - $(RUSTC) delay_span_bug.rs -Z treat-err-as-bug 2>&1 \ - | $(CGREP) "panicked at 'aborting due to \`-Z treat-err-as-bug=1\`'" diff --git a/src/test/run-make-fulldeps/treat-err-as-bug/delay_span_bug.rs b/src/test/run-make-fulldeps/treat-err-as-bug/delay_span_bug.rs deleted file mode 100644 index dad33e498b5..00000000000 --- a/src/test/run-make-fulldeps/treat-err-as-bug/delay_span_bug.rs +++ /dev/null @@ -1,4 +0,0 @@ -#![feature(rustc_attrs)] - -#[rustc_error(delay_span_bug_from_inside_query)] -fn main() {} diff --git a/src/test/run-make-fulldeps/treat-err-as-bug/err.rs b/src/test/run-make-fulldeps/treat-err-as-bug/err.rs deleted file mode 100644 index 136b2f30702..00000000000 --- a/src/test/run-make-fulldeps/treat-err-as-bug/err.rs +++ /dev/null @@ -1,3 +0,0 @@ -#![crate_type="rlib"] - -pub static C: u32 = 0-1; diff --git a/src/test/rustdoc-json/method_abi.rs b/src/test/rustdoc-json/method_abi.rs new file mode 100644 index 00000000000..6fabbc83611 --- /dev/null +++ b/src/test/rustdoc-json/method_abi.rs @@ -0,0 +1,25 @@ +// @has method_abi.json "$.index[*][?(@.name=='Foo')]" +pub struct Foo; + +impl Foo { + // @has - "$.index[*][?(@.name=='abi_rust')].inner.abi" '"\"Rust\""' + pub fn abi_rust() {} + + // @has - "$.index[*][?(@.name=='abi_c')].inner.abi" '"\"C\""' + pub extern "C" fn abi_c() {} + + // @has - "$.index[*][?(@.name=='abi_system')].inner.abi" '"\"system\""' + pub extern "system" fn abi_system() {} +} + +// @has method_abi.json "$.index[*][?(@.name=='Bar')]" +pub trait Bar { + // @has - "$.index[*][?(@.name=='trait_abi_rust')].inner.abi" '"\"Rust\""' + fn trait_abi_rust(); + + // @has - "$.index[*][?(@.name=='trait_abi_c')].inner.abi" '"\"C\""' + extern "C" fn trait_abi_c(); + + // @has - "$.index[*][?(@.name=='trait_abi_system')].inner.abi" '"\"system\""' + extern "system" fn trait_abi_system(); +} diff --git a/src/test/rustdoc-json/traits/has_body.rs b/src/test/rustdoc-json/traits/has_body.rs new file mode 100644 index 00000000000..44dacb1ee75 --- /dev/null +++ b/src/test/rustdoc-json/traits/has_body.rs @@ -0,0 +1,21 @@ +// @has has_body.json "$.index[*][?(@.name=='Foo')]" +pub trait Foo { + // @has - "$.index[*][?(@.name=='no_self')].inner.has_body" false + fn no_self(); + // @has - "$.index[*][?(@.name=='move_self')].inner.has_body" false + fn move_self(self); + // @has - "$.index[*][?(@.name=='ref_self')].inner.has_body" false + fn ref_self(&self); + + // @has - "$.index[*][?(@.name=='no_self_def')].inner.has_body" true + fn no_self_def() {} + // @has - "$.index[*][?(@.name=='move_self_def')].inner.has_body" true + fn move_self_def(self) {} + // @has - "$.index[*][?(@.name=='ref_self_def')].inner.has_body" true + fn ref_self_def(&self) {} +} + +pub trait Bar: Clone { + // @has - "$.index[*][?(@.name=='method')].inner.has_body" false + fn method(&self, param: usize); +} diff --git a/src/test/rustdoc-json/unions/union.rs b/src/test/rustdoc-json/unions/union.rs new file mode 100644 index 00000000000..ac2eb797791 --- /dev/null +++ b/src/test/rustdoc-json/unions/union.rs @@ -0,0 +1,7 @@ +// @has union.json "$.index[*][?(@.name=='Union')].visibility" \"public\" +// @has - "$.index[*][?(@.name=='Union')].kind" \"union\" +// @!has - "$.index[*][?(@.name=='Union')].inner.struct_type" +pub union Union { + int: i32, + float: f32, +} diff --git a/src/test/rustdoc-ui/issue-81662-shortness.rs b/src/test/rustdoc-ui/issue-81662-shortness.rs new file mode 100644 index 00000000000..27a21a313bc --- /dev/null +++ b/src/test/rustdoc-ui/issue-81662-shortness.rs @@ -0,0 +1,12 @@ +// compile-flags:--test --error-format=short +// normalize-stdout-test: "src/test/rustdoc-ui" -> "$$DIR" +// normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME" +// failure-status: 101 + +/// ```rust +/// foo(); +/// ``` +//~^^ ERROR cannot find function `foo` in this scope +fn foo() { + println!("Hello, world!"); +} diff --git a/src/test/rustdoc-ui/issue-81662-shortness.stdout b/src/test/rustdoc-ui/issue-81662-shortness.stdout new file mode 100644 index 00000000000..748113be3a2 --- /dev/null +++ b/src/test/rustdoc-ui/issue-81662-shortness.stdout @@ -0,0 +1,16 @@ + +running 1 test +test $DIR/issue-81662-shortness.rs - foo (line 6) ... FAILED + +failures: + +---- $DIR/issue-81662-shortness.rs - foo (line 6) stdout ---- +$DIR/issue-81662-shortness.rs:7:1: error[E0425]: cannot find function `foo` in this scope +error: aborting due to previous error +Couldn't compile the test. + +failures: + $DIR/issue-81662-shortness.rs - foo (line 6) + +test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME + diff --git a/src/test/rustdoc/task-lists.rs b/src/test/rustdoc/task-lists.rs new file mode 100644 index 00000000000..c2e7dd60f22 --- /dev/null +++ b/src/test/rustdoc/task-lists.rs @@ -0,0 +1,13 @@ +// ignore-tidy-linelength +// FIXME: this doesn't test as much as I'd like; ideally it would have these query too: + // has task_lists/index.html '//li/input[@type="checkbox" and disabled]/following-sibling::text()' 'a' + // has task_lists/index.html '//li/input[@type="checkbox"]/following-sibling::text()' 'b' +// Unfortunately that requires LXML, because the built-in xml module doesn't support all of xpath. + +// @has task_lists/index.html '//ul/li/input[@type="checkbox"]' '' +// @has task_lists/index.html '//ul/li/input[@disabled]' '' +// @has task_lists/index.html '//ul/li' 'a' +// @has task_lists/index.html '//ul/li' 'b' +//! This tests 'task list' support, a common markdown extension. +//! - [ ] a +//! - [x] b diff --git a/src/test/rustdoc/trait-self-link.rs b/src/test/rustdoc/trait-self-link.rs index 51e1fe91f96..bac28b44012 100644 --- a/src/test/rustdoc/trait-self-link.rs +++ b/src/test/rustdoc/trait-self-link.rs @@ -1,4 +1,4 @@ -// @!has trait_self_link/trait.Foo.html //a/@href ../trait_self_link/trait.Foo.html +// @has trait_self_link/trait.Foo.html //a/@href ../trait_self_link/trait.Foo.html pub trait Foo {} pub struct Bar; diff --git a/src/test/ui/allocator/object-safe.rs b/src/test/ui/allocator/object-safe.rs new file mode 100644 index 00000000000..fae7ab7fe33 --- /dev/null +++ b/src/test/ui/allocator/object-safe.rs @@ -0,0 +1,13 @@ +// run-pass + +// Check that `Allocator` is object safe, this allows for polymorphic allocators + +#![feature(allocator_api)] + +use std::alloc::{Allocator, System}; + +fn ensure_object_safe(_: &dyn Allocator) {} + +fn main() { + ensure_object_safe(&System); +} diff --git a/src/test/ui/async-await/async-block-control-flow-static-semantics.stderr b/src/test/ui/async-await/async-block-control-flow-static-semantics.stderr index dbdfb2e71e0..919904ce3b6 100644 --- a/src/test/ui/async-await/async-block-control-flow-static-semantics.stderr +++ b/src/test/ui/async-await/async-block-control-flow-static-semantics.stderr @@ -59,22 +59,22 @@ error[E0308]: mismatched types --> $DIR/async-block-control-flow-static-semantics.rs:47:44 | LL | fn rethrow_targets_async_block_not_fn() -> Result<u8, MyErr> { - | ---------------------------------- ^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found `()` + | ---------------------------------- ^^^^^^^^^^^^^^^^^ expected enum `Result`, found `()` | | | implicitly returns `()` as its body has no tail or `return` expression | - = note: expected enum `std::result::Result<u8, MyErr>` + = note: expected enum `Result<u8, MyErr>` found unit type `()` error[E0308]: mismatched types --> $DIR/async-block-control-flow-static-semantics.rs:56:50 | LL | fn rethrow_targets_async_block_not_async_fn() -> Result<u8, MyErr> { - | ---------------------------------------- ^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found `()` + | ---------------------------------------- ^^^^^^^^^^^^^^^^^ expected enum `Result`, found `()` | | | implicitly returns `()` as its body has no tail or `return` expression | - = note: expected enum `std::result::Result<u8, MyErr>` + = note: expected enum `Result<u8, MyErr>` found unit type `()` error: aborting due to 8 previous errors diff --git a/src/test/ui/async-await/issues/issue-67893.stderr b/src/test/ui/async-await/issues/issue-67893.stderr index af09f0a27bf..aee2ae0e2e4 100644 --- a/src/test/ui/async-await/issues/issue-67893.stderr +++ b/src/test/ui/async-await/issues/issue-67893.stderr @@ -13,9 +13,9 @@ LL | pub async fn run() { | - within this `impl Future` | = help: within `impl Future`, the trait `Send` is not implemented for `MutexGuard<'_, ()>` - = note: required because it appears within the type `for<'r, 's, 't0, 't1, 't2, 't3> {ResumeTy, Arc<Mutex<()>>, &'r Mutex<()>, std::result::Result<MutexGuard<'s, ()>, PoisonError<MutexGuard<'t0, ()>>>, &'t1 MutexGuard<'t2, ()>, MutexGuard<'t3, ()>, (), impl Future}` - = note: required because it appears within the type `[static generator@run::{closure#0} for<'r, 's, 't0, 't1, 't2, 't3> {ResumeTy, Arc<Mutex<()>>, &'r Mutex<()>, std::result::Result<MutexGuard<'s, ()>, PoisonError<MutexGuard<'t0, ()>>>, &'t1 MutexGuard<'t2, ()>, MutexGuard<'t3, ()>, (), impl Future}]` - = note: required because it appears within the type `from_generator::GenFuture<[static generator@run::{closure#0} for<'r, 's, 't0, 't1, 't2, 't3> {ResumeTy, Arc<Mutex<()>>, &'r Mutex<()>, std::result::Result<MutexGuard<'s, ()>, PoisonError<MutexGuard<'t0, ()>>>, &'t1 MutexGuard<'t2, ()>, MutexGuard<'t3, ()>, (), impl Future}]>` + = note: required because it appears within the type `for<'r, 's, 't0, 't1, 't2, 't3> {ResumeTy, Arc<Mutex<()>>, &'r Mutex<()>, Result<MutexGuard<'s, ()>, PoisonError<MutexGuard<'t0, ()>>>, &'t1 MutexGuard<'t2, ()>, MutexGuard<'t3, ()>, (), impl Future}` + = note: required because it appears within the type `[static generator@run::{closure#0} for<'r, 's, 't0, 't1, 't2, 't3> {ResumeTy, Arc<Mutex<()>>, &'r Mutex<()>, Result<MutexGuard<'s, ()>, PoisonError<MutexGuard<'t0, ()>>>, &'t1 MutexGuard<'t2, ()>, MutexGuard<'t3, ()>, (), impl Future}]` + = note: required because it appears within the type `from_generator::GenFuture<[static generator@run::{closure#0} for<'r, 's, 't0, 't1, 't2, 't3> {ResumeTy, Arc<Mutex<()>>, &'r Mutex<()>, Result<MutexGuard<'s, ()>, PoisonError<MutexGuard<'t0, ()>>>, &'t1 MutexGuard<'t2, ()>, MutexGuard<'t3, ()>, (), impl Future}]>` = note: required because it appears within the type `impl Future` = note: required because it appears within the type `impl Future` diff --git a/src/test/ui/attributes/key-value-non-ascii.rs b/src/test/ui/attributes/key-value-non-ascii.rs index 91c917e7db5..12942eabdf7 100644 --- a/src/test/ui/attributes/key-value-non-ascii.rs +++ b/src/test/ui/attributes/key-value-non-ascii.rs @@ -1,4 +1,4 @@ #![feature(rustc_attrs)] -#[rustc_dummy = b"ffi.rs"] //~ ERROR byte constant must be ASCII +#[rustc_dummy = b"ffi.rs"] //~ ERROR non-ASCII character in byte constant fn main() {} diff --git a/src/test/ui/attributes/key-value-non-ascii.stderr b/src/test/ui/attributes/key-value-non-ascii.stderr index 3e082139f89..1d4b0d5b2b1 100644 --- a/src/test/ui/attributes/key-value-non-ascii.stderr +++ b/src/test/ui/attributes/key-value-non-ascii.stderr @@ -1,8 +1,11 @@ -error: byte constant must be ASCII. Use a \xHH escape for a non-ASCII byte +error: non-ASCII character in byte constant --> $DIR/key-value-non-ascii.rs:3:19 | LL | #[rustc_dummy = b"ffi.rs"] | ^ + | | + | byte constant must be ASCII + | help: use a \xHH escape for a non-ASCII byte: `\xFB03` error: aborting due to previous error diff --git a/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr b/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr index da8db4331df..df1fb58e25a 100644 --- a/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr +++ b/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr @@ -12,13 +12,13 @@ error[E0308]: mismatched types --> $DIR/coercion-missing-tail-expected-type.rs:8:13 | LL | fn foo() -> Result<u8, u64> { - | --- ^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found `()` + | --- ^^^^^^^^^^^^^^^ expected enum `Result`, found `()` | | | implicitly returns `()` as its body has no tail or `return` expression LL | Ok(1); | - help: consider removing this semicolon | - = note: expected enum `std::result::Result<u8, u64>` + = note: expected enum `Result<u8, u64>` found unit type `()` error: aborting due to 2 previous errors diff --git a/src/test/ui/const-generics/const_evaluatable_checked/cross_crate_predicate.stderr b/src/test/ui/const-generics/const_evaluatable_checked/cross_crate_predicate.stderr index 92547ca4796..1beb5315d10 100644 --- a/src/test/ui/const-generics/const_evaluatable_checked/cross_crate_predicate.stderr +++ b/src/test/ui/const-generics/const_evaluatable_checked/cross_crate_predicate.stderr @@ -4,7 +4,7 @@ error: unconstrained generic constant LL | let _ = const_evaluatable_lib::test1::<T>(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | -help: try adding a `where` bound using this expression: where [u8; std::mem::size_of::<T>() - 1]: Sized +help: try adding a `where` bound using this expression: `where [u8; std::mem::size_of::<T>() - 1]: Sized` --> $DIR/auxiliary/const_evaluatable_lib.rs:6:10 | LL | [u8; std::mem::size_of::<T>() - 1]: Sized, @@ -16,7 +16,7 @@ error: unconstrained generic constant LL | let _ = const_evaluatable_lib::test1::<T>(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | -help: try adding a `where` bound using this expression: where [u8; std::mem::size_of::<T>() - 1]: Sized +help: try adding a `where` bound using this expression: `where [u8; std::mem::size_of::<T>() - 1]: Sized` --> $DIR/auxiliary/const_evaluatable_lib.rs:4:27 | LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1] @@ -28,7 +28,7 @@ error: unconstrained generic constant LL | let _ = const_evaluatable_lib::test1::<T>(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | -help: try adding a `where` bound using this expression: where [u8; std::mem::size_of::<T>() - 1]: Sized +help: try adding a `where` bound using this expression: `where [u8; std::mem::size_of::<T>() - 1]: Sized` --> $DIR/auxiliary/const_evaluatable_lib.rs:6:10 | LL | [u8; std::mem::size_of::<T>() - 1]: Sized, @@ -40,7 +40,7 @@ error: unconstrained generic constant LL | let _ = const_evaluatable_lib::test1::<T>(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | -help: try adding a `where` bound using this expression: where [u8; std::mem::size_of::<T>() - 1]: Sized +help: try adding a `where` bound using this expression: `where [u8; std::mem::size_of::<T>() - 1]: Sized` --> $DIR/auxiliary/const_evaluatable_lib.rs:4:27 | LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1] diff --git a/src/test/ui/const-generics/const_evaluatable_checked/different-fn.stderr b/src/test/ui/const-generics/const_evaluatable_checked/different-fn.stderr index 00efb610004..8cdc9b57750 100644 --- a/src/test/ui/const-generics/const_evaluatable_checked/different-fn.stderr +++ b/src/test/ui/const-generics/const_evaluatable_checked/different-fn.stderr @@ -4,7 +4,7 @@ error: unconstrained generic constant LL | [0; size_of::<Foo<T>>()] | ^^^^^^^^^^^^^^^^^^^ | -help: try adding a `where` bound using this expression: where [u8; size_of::<Foo<T>>()]: Sized +help: try adding a `where` bound using this expression: `where [u8; size_of::<Foo<T>>()]: Sized` --> $DIR/different-fn.rs:10:9 | LL | [0; size_of::<Foo<T>>()] diff --git a/src/test/ui/const_evaluatable/needs_where_clause.stderr b/src/test/ui/const_evaluatable/needs_where_clause.stderr index e991c508c03..945105d1a2d 100644 --- a/src/test/ui/const_evaluatable/needs_where_clause.stderr +++ b/src/test/ui/const_evaluatable/needs_where_clause.stderr @@ -4,7 +4,7 @@ error: unconstrained generic constant LL | b: [f32; complex_maths::<T>(N)], | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | -help: try adding a `where` bound using this expression: where [u8; complex_maths::<T>(N)]: Sized +help: try adding a `where` bound using this expression: `where [u8; complex_maths::<T>(N)]: Sized` --> $DIR/needs_where_clause.rs:11:12 | LL | b: [f32; complex_maths::<T>(N)], diff --git a/src/test/ui/const_evaluatable/no_where_clause.stderr b/src/test/ui/const_evaluatable/no_where_clause.stderr index 65100909e53..84a65f0d1d2 100644 --- a/src/test/ui/const_evaluatable/no_where_clause.stderr +++ b/src/test/ui/const_evaluatable/no_where_clause.stderr @@ -4,7 +4,7 @@ error: unconstrained generic constant LL | b: [f32; complex_maths(N)], | ^^^^^^^^^^^^^^^^^^^^^^^ | -help: try adding a `where` bound using this expression: where [u8; complex_maths(N)]: Sized +help: try adding a `where` bound using this expression: `where [u8; complex_maths(N)]: Sized` --> $DIR/no_where_clause.rs:10:12 | LL | b: [f32; complex_maths(N)], diff --git a/src/test/ui/consts/const-eval/simd/insert_extract.rs b/src/test/ui/consts/const-eval/simd/insert_extract.rs index 92231d4ced3..9e5cb0d4eb1 100644 --- a/src/test/ui/consts/const-eval/simd/insert_extract.rs +++ b/src/test/ui/consts/const-eval/simd/insert_extract.rs @@ -8,7 +8,7 @@ #[repr(simd)] struct i8x1(i8); #[repr(simd)] struct u16x2(u16, u16); -#[repr(simd)] struct f32x3(f32, f32, f32); +#[repr(simd)] struct f32x4(f32, f32, f32, f32); extern "platform-intrinsic" { #[rustc_const_stable(feature = "foo", since = "1.3.37")] @@ -39,19 +39,23 @@ fn main() { assert_eq!(Y1, 42); } { - const U: f32x3 = f32x3(13., 14., 15.); - const V: f32x3 = unsafe { simd_insert(U, 1_u32, 42_f32) }; + const U: f32x4 = f32x4(13., 14., 15., 16.); + const V: f32x4 = unsafe { simd_insert(U, 1_u32, 42_f32) }; const X0: f32 = V.0; const X1: f32 = V.1; const X2: f32 = V.2; + const X3: f32 = V.3; const Y0: f32 = unsafe { simd_extract(V, 0) }; const Y1: f32 = unsafe { simd_extract(V, 1) }; const Y2: f32 = unsafe { simd_extract(V, 2) }; + const Y3: f32 = unsafe { simd_extract(V, 3) }; assert_eq!(X0, 13.); assert_eq!(X1, 42.); assert_eq!(X2, 15.); + assert_eq!(X3, 16.); assert_eq!(Y0, 13.); assert_eq!(Y1, 42.); assert_eq!(Y2, 15.); + assert_eq!(Y3, 16.); } } diff --git a/src/test/ui/consts/const-int-arithmetic.rs b/src/test/ui/consts/const-int-arithmetic.rs index e0d722ede94..b9096648f92 100644 --- a/src/test/ui/consts/const-int-arithmetic.rs +++ b/src/test/ui/consts/const-int-arithmetic.rs @@ -1,10 +1,5 @@ // run-pass -#![feature(const_checked_int_methods)] -#![feature(const_euclidean_int_methods)] -#![feature(const_overflowing_int_methods)] -#![feature(const_wrapping_int_methods)] - macro_rules! suite { ($( $fn:ident -> $ty:ty { $( $label:ident : $expr:expr, $result:expr; )* } diff --git a/src/test/ui/derives/derive-deadlock.rs b/src/test/ui/derives/derive-deadlock.rs new file mode 100644 index 00000000000..0137b1e5bfb --- /dev/null +++ b/src/test/ui/derives/derive-deadlock.rs @@ -0,0 +1,6 @@ +use std as derive; + +#[derive(Default)] //~ ERROR cannot determine resolution for the attribute macro `derive` +struct S; + +fn main() {} diff --git a/src/test/ui/derives/derive-deadlock.stderr b/src/test/ui/derives/derive-deadlock.stderr new file mode 100644 index 00000000000..8d062491c6a --- /dev/null +++ b/src/test/ui/derives/derive-deadlock.stderr @@ -0,0 +1,10 @@ +error: cannot determine resolution for the attribute macro `derive` + --> $DIR/derive-deadlock.rs:3:3 + | +LL | #[derive(Default)] + | ^^^^^^ + | + = note: import resolution is stuck, try simplifying macro imports + +error: aborting due to previous error + diff --git a/src/test/ui/derives/derive-multiple-with-packed.rs b/src/test/ui/derives/derive-multiple-with-packed.rs new file mode 100644 index 00000000000..e762ee357ca --- /dev/null +++ b/src/test/ui/derives/derive-multiple-with-packed.rs @@ -0,0 +1,10 @@ +// check-pass + +#[derive(Clone, Copy)] +#[derive(Debug)] // OK, even if `Copy` is in the different `#[derive]` +#[repr(packed)] +struct CacheRecordHeader { + field: u64, +} + +fn main() {} diff --git a/src/test/ui/derives/derive-renamed.rs b/src/test/ui/derives/derive-renamed.rs new file mode 100644 index 00000000000..d310e5806c5 --- /dev/null +++ b/src/test/ui/derives/derive-renamed.rs @@ -0,0 +1,11 @@ +// check-pass +// edition:2018 + +use derive as my_derive; + +#[my_derive(Debug)] +struct S; + +fn main() { + println!("{:?}", S); // OK +} diff --git a/src/test/ui/derives/deriving-meta-empty-trait-list.rs b/src/test/ui/derives/deriving-meta-empty-trait-list.rs index 4f2e31e8efb..0306ce717d0 100644 --- a/src/test/ui/derives/deriving-meta-empty-trait-list.rs +++ b/src/test/ui/derives/deriving-meta-empty-trait-list.rs @@ -1,6 +1,8 @@ +// check-pass + #![deny(unused)] -#[derive()] //~ ERROR unused attribute +#[derive()] // OK struct _Bar; pub fn main() {} diff --git a/src/test/ui/derives/deriving-meta-empty-trait-list.stderr b/src/test/ui/derives/deriving-meta-empty-trait-list.stderr deleted file mode 100644 index 1fd7d58c86a..00000000000 --- a/src/test/ui/derives/deriving-meta-empty-trait-list.stderr +++ /dev/null @@ -1,15 +0,0 @@ -error: unused attribute - --> $DIR/deriving-meta-empty-trait-list.rs:3:1 - | -LL | #[derive()] - | ^^^^^^^^^^^ - | -note: the lint level is defined here - --> $DIR/deriving-meta-empty-trait-list.rs:1:9 - | -LL | #![deny(unused)] - | ^^^^^^ - = note: `#[deny(unused_attributes)]` implied by `#[deny(unused)]` - -error: aborting due to previous error - diff --git a/src/test/ui/derives/issue-36617.rs b/src/test/ui/derives/issue-36617.rs index 1102f3c4640..08fc82e91f6 100644 --- a/src/test/ui/derives/issue-36617.rs +++ b/src/test/ui/derives/issue-36617.rs @@ -1,4 +1,3 @@ -#![derive(Copy)] //~ ERROR `derive` may only be applied to structs, enums and unions - //~| ERROR cannot determine resolution for the derive macro `Copy` +#![derive(Copy)] //~ ERROR cannot determine resolution for the attribute macro `derive` fn main() {} diff --git a/src/test/ui/derives/issue-36617.stderr b/src/test/ui/derives/issue-36617.stderr index dc6ef169259..0716764b427 100644 --- a/src/test/ui/derives/issue-36617.stderr +++ b/src/test/ui/derives/issue-36617.stderr @@ -1,17 +1,10 @@ -error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-36617.rs:1:1 +error: cannot determine resolution for the attribute macro `derive` + --> $DIR/issue-36617.rs:1:4 | LL | #![derive(Copy)] - | ^^^^^^^^^^^^^^^^ help: try an outer attribute: `#[derive(Copy)]` - -error: cannot determine resolution for the derive macro `Copy` - --> $DIR/issue-36617.rs:1:11 - | -LL | #![derive(Copy)] - | ^^^^ + | ^^^^^^ | = note: import resolution is stuck, try simplifying macro imports -error: aborting due to 2 previous errors +error: aborting due to previous error -For more information about this error, try `rustc --explain E0774`. diff --git a/src/test/ui/drop/dynamic-drop-async.rs b/src/test/ui/drop/dynamic-drop-async.rs index cb6d58a23d9..c0bf0bdf731 100644 --- a/src/test/ui/drop/dynamic-drop-async.rs +++ b/src/test/ui/drop/dynamic-drop-async.rs @@ -43,7 +43,6 @@ impl<T: Unpin> Future for Defer<T> { /// The `failing_op`-th operation will panic. struct Allocator { data: RefCell<Vec<bool>>, - name: &'static str, failing_op: usize, cur_ops: Cell<usize>, } @@ -55,28 +54,23 @@ impl Drop for Allocator { fn drop(&mut self) { let data = self.data.borrow(); if data.iter().any(|d| *d) { - panic!("missing free in {:?}: {:?}", self.name, data); + panic!("missing free: {:?}", data); } } } impl Allocator { - fn new(failing_op: usize, name: &'static str) -> Self { - Allocator { - failing_op, - name, - cur_ops: Cell::new(0), - data: RefCell::new(vec![]), - } + fn new(failing_op: usize) -> Self { + Allocator { failing_op, cur_ops: Cell::new(0), data: RefCell::new(vec![]) } } - fn alloc(self: &Rc<Allocator>) -> impl Future<Output = Ptr> + 'static { + fn alloc(&self) -> impl Future<Output = Ptr<'_>> + '_ { self.fallible_operation(); let mut data = self.data.borrow_mut(); let addr = data.len(); data.push(true); - Defer { ready: false, value: Some(Ptr(addr, self.clone())) } + Defer { ready: false, value: Some(Ptr(addr, self)) } } fn fallible_operation(&self) { self.cur_ops.set(self.cur_ops.get() + 1); @@ -89,11 +83,11 @@ impl Allocator { // Type that tracks whether it was dropped and can panic when it's created or // destroyed. -struct Ptr(usize, Rc<Allocator>); -impl Drop for Ptr { +struct Ptr<'a>(usize, &'a Allocator); +impl<'a> Drop for Ptr<'a> { fn drop(&mut self) { match self.1.data.borrow_mut()[self.0] { - false => panic!("double free in {:?} at index {:?}", self.1.name, self.0), + false => panic!("double free at index {:?}", self.0), ref mut d => *d = false, } @@ -117,7 +111,7 @@ async fn dynamic_drop(a: Rc<Allocator>, c: bool) { }; } -struct TwoPtrs(Ptr, Ptr); +struct TwoPtrs<'a>(Ptr<'a>, Ptr<'a>); async fn struct_dynamic_drop(a: Rc<Allocator>, c0: bool, c1: bool, c: bool) { for i in 0..2 { let x; @@ -238,62 +232,21 @@ async fn move_ref_pattern(a: Rc<Allocator>) { a.alloc().await; } -async fn panic_after_return(a: Rc<Allocator>, c: bool) -> (Ptr,) { - a.alloc().await; - let p = a.alloc().await; - if c { - a.alloc().await; - let q = a.alloc().await; - // We use a return type that isn't used anywhere else to make sure that - // the return place doesn't incorrectly end up in the generator state. - return (a.alloc().await,); - } - (a.alloc().await,) -} - - -async fn panic_after_init_by_loop(a: Rc<Allocator>) { - a.alloc().await; - let p = a.alloc().await; - let q = loop { - a.alloc().await; - let r = a.alloc().await; - break a.alloc().await; - }; -} - -async fn panic_after_init_by_match_with_bindings_and_guard(a: Rc<Allocator>, b: bool) { - a.alloc().await; - let p = a.alloc().await; - let q = match a.alloc().await { - ref _x if b => { - a.alloc().await; - let r = a.alloc().await; - a.alloc().await - } - _x => { - a.alloc().await; - let r = a.alloc().await; - a.alloc().await - }, - }; -} - -fn run_test<F, G, O>(cx: &mut Context<'_>, ref f: F, name: &'static str) +fn run_test<F, G>(cx: &mut Context<'_>, ref f: F) where F: Fn(Rc<Allocator>) -> G, - G: Future<Output = O>, + G: Future<Output = ()>, { for polls in 0.. { // Run without any panics to find which operations happen after the // penultimate `poll`. - let first_alloc = Rc::new(Allocator::new(usize::MAX, name)); + let first_alloc = Rc::new(Allocator::new(usize::MAX)); let mut fut = Box::pin(f(first_alloc.clone())); let mut ops_before_last_poll = 0; let mut completed = false; for _ in 0..polls { ops_before_last_poll = first_alloc.cur_ops.get(); - if let Poll::Ready(_) = fut.as_mut().poll(cx) { + if let Poll::Ready(()) = fut.as_mut().poll(cx) { completed = true; } } @@ -302,7 +255,7 @@ where // Start at `ops_before_last_poll` so that we will always be able to // `poll` the expected number of times. for failing_op in ops_before_last_poll..first_alloc.cur_ops.get() { - let alloc = Rc::new(Allocator::new(failing_op + 1, name)); + let alloc = Rc::new(Allocator::new(failing_op + 1)); let f = &f; let cx = &mut *cx; let result = panic::catch_unwind(panic::AssertUnwindSafe(move || { @@ -332,58 +285,48 @@ fn clone_waker(data: *const ()) -> RawWaker { RawWaker::new(data, &RawWakerVTable::new(clone_waker, drop, drop, drop)) } -macro_rules! run_test { - ($ctxt:expr, $e:expr) => { run_test($ctxt, $e, stringify!($e)); }; -} - fn main() { let waker = unsafe { Waker::from_raw(clone_waker(ptr::null())) }; let context = &mut Context::from_waker(&waker); - run_test!(context, |a| dynamic_init(a, false)); - run_test!(context, |a| dynamic_init(a, true)); - run_test!(context, |a| dynamic_drop(a, false)); - run_test!(context, |a| dynamic_drop(a, true)); - - run_test!(context, |a| assignment(a, false, false)); - run_test!(context, |a| assignment(a, false, true)); - run_test!(context, |a| assignment(a, true, false)); - run_test!(context, |a| assignment(a, true, true)); - - run_test!(context, |a| array_simple(a)); - run_test!(context, |a| vec_simple(a)); - run_test!(context, |a| vec_unreachable(a)); - - run_test!(context, |a| struct_dynamic_drop(a, false, false, false)); - run_test!(context, |a| struct_dynamic_drop(a, false, false, true)); - run_test!(context, |a| struct_dynamic_drop(a, false, true, false)); - run_test!(context, |a| struct_dynamic_drop(a, false, true, true)); - run_test!(context, |a| struct_dynamic_drop(a, true, false, false)); - run_test!(context, |a| struct_dynamic_drop(a, true, false, true)); - run_test!(context, |a| struct_dynamic_drop(a, true, true, false)); - run_test!(context, |a| struct_dynamic_drop(a, true, true, true)); - - run_test!(context, |a| field_assignment(a, false)); - run_test!(context, |a| field_assignment(a, true)); - - run_test!(context, |a| mixed_drop_and_nondrop(a)); - - run_test!(context, |a| slice_pattern_one_of(a, 0)); - run_test!(context, |a| slice_pattern_one_of(a, 1)); - run_test!(context, |a| slice_pattern_one_of(a, 2)); - run_test!(context, |a| slice_pattern_one_of(a, 3)); - - run_test!(context, |a| subslice_pattern_from_end_with_drop(a, true, true)); - run_test!(context, |a| subslice_pattern_from_end_with_drop(a, true, false)); - run_test!(context, |a| subslice_pattern_from_end_with_drop(a, false, true)); - run_test!(context, |a| subslice_pattern_from_end_with_drop(a, false, false)); - run_test!(context, |a| subslice_pattern_reassign(a)); - - run_test!(context, |a| move_ref_pattern(a)); - - run_test!(context, |a| panic_after_return(a, false)); - run_test!(context, |a| panic_after_return(a, true)); - run_test!(context, |a| panic_after_init_by_loop(a)); - run_test!(context, |a| panic_after_init_by_match_with_bindings_and_guard(a, false)); - run_test!(context, |a| panic_after_init_by_match_with_bindings_and_guard(a, true)); + run_test(context, |a| dynamic_init(a, false)); + run_test(context, |a| dynamic_init(a, true)); + run_test(context, |a| dynamic_drop(a, false)); + run_test(context, |a| dynamic_drop(a, true)); + + run_test(context, |a| assignment(a, false, false)); + run_test(context, |a| assignment(a, false, true)); + run_test(context, |a| assignment(a, true, false)); + run_test(context, |a| assignment(a, true, true)); + + run_test(context, |a| array_simple(a)); + run_test(context, |a| vec_simple(a)); + run_test(context, |a| vec_unreachable(a)); + + run_test(context, |a| struct_dynamic_drop(a, false, false, false)); + run_test(context, |a| struct_dynamic_drop(a, false, false, true)); + run_test(context, |a| struct_dynamic_drop(a, false, true, false)); + run_test(context, |a| struct_dynamic_drop(a, false, true, true)); + run_test(context, |a| struct_dynamic_drop(a, true, false, false)); + run_test(context, |a| struct_dynamic_drop(a, true, false, true)); + run_test(context, |a| struct_dynamic_drop(a, true, true, false)); + run_test(context, |a| struct_dynamic_drop(a, true, true, true)); + + run_test(context, |a| field_assignment(a, false)); + run_test(context, |a| field_assignment(a, true)); + + run_test(context, |a| mixed_drop_and_nondrop(a)); + + run_test(context, |a| slice_pattern_one_of(a, 0)); + run_test(context, |a| slice_pattern_one_of(a, 1)); + run_test(context, |a| slice_pattern_one_of(a, 2)); + run_test(context, |a| slice_pattern_one_of(a, 3)); + + run_test(context, |a| subslice_pattern_from_end_with_drop(a, true, true)); + run_test(context, |a| subslice_pattern_from_end_with_drop(a, true, false)); + run_test(context, |a| subslice_pattern_from_end_with_drop(a, false, true)); + run_test(context, |a| subslice_pattern_from_end_with_drop(a, false, false)); + run_test(context, |a| subslice_pattern_reassign(a)); + + run_test(context, |a| move_ref_pattern(a)); } diff --git a/src/test/ui/drop/dynamic-drop.rs b/src/test/ui/drop/dynamic-drop.rs index e28bedb982d..e90ea1c55b0 100644 --- a/src/test/ui/drop/dynamic-drop.rs +++ b/src/test/ui/drop/dynamic-drop.rs @@ -3,6 +3,7 @@ #![feature(generators, generator_trait)] #![feature(bindings_after_at)] + #![allow(unused_assignments)] #![allow(unused_variables)] @@ -16,7 +17,6 @@ struct InjectedFailure; struct Allocator { data: RefCell<Vec<bool>>, - name: &'static str, failing_op: usize, cur_ops: Cell<usize>, } @@ -28,18 +28,17 @@ impl Drop for Allocator { fn drop(&mut self) { let data = self.data.borrow(); if data.iter().any(|d| *d) { - panic!("missing free in {:?}: {:?}", self.name, data); + panic!("missing free: {:?}", data); } } } impl Allocator { - fn new(failing_op: usize, name: &'static str) -> Self { + fn new(failing_op: usize) -> Self { Allocator { failing_op: failing_op, cur_ops: Cell::new(0), - data: RefCell::new(vec![]), - name, + data: RefCell::new(vec![]) } } fn alloc(&self) -> Ptr<'_> { @@ -54,17 +53,33 @@ impl Allocator { data.push(true); Ptr(addr, self) } + // FIXME(#47949) Any use of this indicates a bug in rustc: we should never + // be leaking values in the cases here. + // + // Creates a `Ptr<'_>` and checks that the allocated value is leaked if the + // `failing_op` is in the list of exception. + fn alloc_leaked(&self, exceptions: Vec<usize>) -> Ptr<'_> { + let ptr = self.alloc(); + + if exceptions.iter().any(|operation| *operation == self.failing_op) { + let mut data = self.data.borrow_mut(); + data[ptr.0] = false; + } + ptr + } } struct Ptr<'a>(usize, &'a Allocator); impl<'a> Drop for Ptr<'a> { fn drop(&mut self) { match self.1.data.borrow_mut()[self.0] { - false => panic!("double free in {:?} at index {:?}", self.1.name, self.0), - ref mut d => *d = false, + false => { + panic!("double free at index {:?}", self.0) + } + ref mut d => *d = false } - self.1.cur_ops.set(self.1.cur_ops.get() + 1); + self.1.cur_ops.set(self.1.cur_ops.get()+1); if self.1.cur_ops.get() == self.1.failing_op { panic::panic_any(InjectedFailure); @@ -162,7 +177,11 @@ fn generator(a: &Allocator, run_count: usize) { assert!(run_count < 4); let mut gen = || { - (a.alloc(), yield a.alloc(), a.alloc(), yield a.alloc()); + (a.alloc(), + yield a.alloc(), + a.alloc(), + yield a.alloc() + ); }; for _ in 0..run_count { Pin::new(&mut gen).resume(()); @@ -186,40 +205,28 @@ fn vec_unreachable(a: &Allocator) { } fn slice_pattern_first(a: &Allocator) { - let [_x, ..] = [a.alloc(), a.alloc(), a.alloc()]; + let[_x, ..] = [a.alloc(), a.alloc(), a.alloc()]; } fn slice_pattern_middle(a: &Allocator) { - let [_, _x, _] = [a.alloc(), a.alloc(), a.alloc()]; + let[_, _x, _] = [a.alloc(), a.alloc(), a.alloc()]; } fn slice_pattern_two(a: &Allocator) { - let [_x, _, _y, _] = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; + let[_x, _, _y, _] = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; } fn slice_pattern_last(a: &Allocator) { - let [.., _y] = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; + let[.., _y] = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; } fn slice_pattern_one_of(a: &Allocator, i: usize) { let array = [a.alloc(), a.alloc(), a.alloc(), a.alloc()]; let _x = match i { - 0 => { - let [a, ..] = array; - a - } - 1 => { - let [_, a, ..] = array; - a - } - 2 => { - let [_, _, a, _] = array; - a - } - 3 => { - let [_, _, _, a] = array; - a - } + 0 => { let [a, ..] = array; a } + 1 => { let [_, a, ..] = array; a } + 2 => { let [_, _, a, _] = array; a } + 3 => { let [_, _, _, a] = array; a } _ => panic!("unmatched"), }; } @@ -227,9 +234,9 @@ fn slice_pattern_one_of(a: &Allocator, i: usize) { fn subslice_pattern_from_end(a: &Allocator, arg: bool) { let a = [a.alloc(), a.alloc(), a.alloc()]; if arg { - let [.., _x, _] = a; + let[.., _x, _] = a; } else { - let [_, _y @ ..] = a; + let[_, _y @ ..] = a; } } @@ -241,61 +248,45 @@ fn subslice_pattern_from_end_with_drop(a: &Allocator, arg: bool, arg2: bool) { } if arg { - let [.., _x, _] = a; + let[.., _x, _] = a; } else { - let [_, _y @ ..] = a; + let[_, _y @ ..] = a; } } fn slice_pattern_reassign(a: &Allocator) { let mut ar = [a.alloc(), a.alloc()]; - let [_, _x] = ar; + let[_, _x] = ar; ar = [a.alloc(), a.alloc()]; - let [.., _y] = ar; + let[.., _y] = ar; } fn subslice_pattern_reassign(a: &Allocator) { let mut ar = [a.alloc(), a.alloc(), a.alloc()]; - let [_, _, _x] = ar; + let[_, _, _x] = ar; ar = [a.alloc(), a.alloc(), a.alloc()]; - let [_, _y @ ..] = ar; + let[_, _y @ ..] = ar; } fn index_field_mixed_ends(a: &Allocator) { let ar = [(a.alloc(), a.alloc()), (a.alloc(), a.alloc())]; - let [(_x, _), ..] = ar; - let [(_, _y), _] = ar; - let [_, (_, _w)] = ar; - let [.., (_z, _)] = ar; + let[(_x, _), ..] = ar; + let[(_, _y), _] = ar; + let[_, (_, _w)] = ar; + let[.., (_z, _)] = ar; } fn subslice_mixed_min_lengths(a: &Allocator, c: i32) { let ar = [(a.alloc(), a.alloc()), (a.alloc(), a.alloc())]; match c { - 0 => { - let [_x, ..] = ar; - } - 1 => { - let [_x, _, ..] = ar; - } - 2 => { - let [_x, _] = ar; - } - 3 => { - let [(_x, _), _, ..] = ar; - } - 4 => { - let [.., (_x, _)] = ar; - } - 5 => { - let [.., (_x, _), _] = ar; - } - 6 => { - let [_y @ ..] = ar; - } - _ => { - let [_y @ .., _] = ar; - } + 0 => { let[_x, ..] = ar; } + 1 => { let[_x, _, ..] = ar; } + 2 => { let[_x, _] = ar; } + 3 => { let[(_x, _), _, ..] = ar; } + 4 => { let[.., (_x, _)] = ar; } + 5 => { let[.., (_x, _), _] = ar; } + 6 => { let [_y @ ..] = ar; } + _ => { let [_y @ .., _] = ar; } } } @@ -343,160 +334,87 @@ fn move_ref_pattern(a: &Allocator) { } fn panic_after_return(a: &Allocator) -> Ptr<'_> { + // Panic in the drop of `p` or `q` can leak + let exceptions = vec![8, 9]; a.alloc(); let p = a.alloc(); { a.alloc(); let p = a.alloc(); - a.alloc() + // FIXME (#47949) We leak values when we panic in a destructor after + // evaluating an expression with `rustc_mir::build::Builder::into`. + a.alloc_leaked(exceptions) } } fn panic_after_return_expr(a: &Allocator) -> Ptr<'_> { + // Panic in the drop of `p` or `q` can leak + let exceptions = vec![8, 9]; a.alloc(); let p = a.alloc(); { a.alloc(); let q = a.alloc(); - return a.alloc(); + // FIXME (#47949) + return a.alloc_leaked(exceptions); } } fn panic_after_init(a: &Allocator) { + // Panic in the drop of `r` can leak + let exceptions = vec![8]; a.alloc(); let p = a.alloc(); let q = { a.alloc(); let r = a.alloc(); - a.alloc() + // FIXME (#47949) + a.alloc_leaked(exceptions) }; } fn panic_after_init_temp(a: &Allocator) { + // Panic in the drop of `r` can leak + let exceptions = vec![8]; a.alloc(); let p = a.alloc(); { a.alloc(); let r = a.alloc(); - a.alloc() + // FIXME (#47949) + a.alloc_leaked(exceptions) }; } fn panic_after_init_by_loop(a: &Allocator) { + // Panic in the drop of `r` can leak + let exceptions = vec![8]; a.alloc(); let p = a.alloc(); let q = loop { a.alloc(); let r = a.alloc(); - break a.alloc(); - }; -} - -fn panic_after_init_by_match(a: &Allocator, b: bool) { - a.alloc(); - let p = a.alloc(); - let _ = loop { - let q = match b { - true => { - a.alloc(); - let r = a.alloc(); - a.alloc() - } - false => { - a.alloc(); - let r = a.alloc(); - break a.alloc(); - } - }; - return; - }; -} - -fn panic_after_init_by_match_with_guard(a: &Allocator, b: bool) { - a.alloc(); - let p = a.alloc(); - let q = match a.alloc() { - _ if b => { - a.alloc(); - let r = a.alloc(); - a.alloc() - } - _ => { - a.alloc(); - let r = a.alloc(); - a.alloc() - } - }; -} - -fn panic_after_init_by_match_with_bindings_and_guard(a: &Allocator, b: bool) { - a.alloc(); - let p = a.alloc(); - let q = match a.alloc() { - _x if b => { - a.alloc(); - let r = a.alloc(); - a.alloc() - } - _x => { - a.alloc(); - let r = a.alloc(); - a.alloc() - } - }; -} - -fn panic_after_init_by_match_with_ref_bindings_and_guard(a: &Allocator, b: bool) { - a.alloc(); - let p = a.alloc(); - let q = match a.alloc() { - ref _x if b => { - a.alloc(); - let r = a.alloc(); - a.alloc() - } - ref _x => { - a.alloc(); - let r = a.alloc(); - a.alloc() - } - }; -} - -fn panic_after_init_by_break_if(a: &Allocator, b: bool) { - a.alloc(); - let p = a.alloc(); - let q = loop { - let r = a.alloc(); - break if b { - let s = a.alloc(); - a.alloc() - } else { - a.alloc() - }; + // FIXME (#47949) + break a.alloc_leaked(exceptions); }; } -fn run_test<F>(mut f: F, name: &'static str) -where - F: FnMut(&Allocator), +fn run_test<F>(mut f: F) + where F: FnMut(&Allocator) { - let first_alloc = Allocator::new(usize::MAX, name); + let first_alloc = Allocator::new(usize::MAX); f(&first_alloc); - for failing_op in 1..first_alloc.cur_ops.get() + 1 { - let alloc = Allocator::new(failing_op, name); + for failing_op in 1..first_alloc.cur_ops.get()+1 { + let alloc = Allocator::new(failing_op); let alloc = &alloc; let f = panic::AssertUnwindSafe(&mut f); let result = panic::catch_unwind(move || { f.0(alloc); }); match result { - Ok(..) => panic!( - "test executed {} ops but now {}", - first_alloc.cur_ops.get(), - alloc.cur_ops.get() - ), + Ok(..) => panic!("test executed {} ops but now {}", + first_alloc.cur_ops.get(), alloc.cur_ops.get()), Err(e) => { if e.downcast_ref::<InjectedFailure>().is_none() { panic::resume_unwind(e); @@ -506,115 +424,98 @@ where } } -fn run_test_nopanic<F>(mut f: F, name: &'static str) -where - F: FnMut(&Allocator), +fn run_test_nopanic<F>(mut f: F) + where F: FnMut(&Allocator) { - let first_alloc = Allocator::new(usize::MAX, name); + let first_alloc = Allocator::new(usize::MAX); f(&first_alloc); } -macro_rules! run_test { - ($e:expr) => { - run_test($e, stringify!($e)); - }; -} - fn main() { - run_test!(|a| dynamic_init(a, false)); - run_test!(|a| dynamic_init(a, true)); - run_test!(|a| dynamic_drop(a, false)); - run_test!(|a| dynamic_drop(a, true)); - - run_test!(|a| assignment2(a, false, false)); - run_test!(|a| assignment2(a, false, true)); - run_test!(|a| assignment2(a, true, false)); - run_test!(|a| assignment2(a, true, true)); - - run_test!(|a| assignment1(a, false)); - run_test!(|a| assignment1(a, true)); - - run_test!(|a| array_simple(a)); - run_test!(|a| vec_simple(a)); - run_test!(|a| vec_unreachable(a)); - - run_test!(|a| struct_dynamic_drop(a, false, false, false)); - run_test!(|a| struct_dynamic_drop(a, false, false, true)); - run_test!(|a| struct_dynamic_drop(a, false, true, false)); - run_test!(|a| struct_dynamic_drop(a, false, true, true)); - run_test!(|a| struct_dynamic_drop(a, true, false, false)); - run_test!(|a| struct_dynamic_drop(a, true, false, true)); - run_test!(|a| struct_dynamic_drop(a, true, true, false)); - run_test!(|a| struct_dynamic_drop(a, true, true, true)); - - run_test!(|a| field_assignment(a, false)); - run_test!(|a| field_assignment(a, true)); - - run_test!(|a| generator(a, 0)); - run_test!(|a| generator(a, 1)); - run_test!(|a| generator(a, 2)); - run_test!(|a| generator(a, 3)); - - run_test!(|a| mixed_drop_and_nondrop(a)); - - run_test!(|a| slice_pattern_first(a)); - run_test!(|a| slice_pattern_middle(a)); - run_test!(|a| slice_pattern_two(a)); - run_test!(|a| slice_pattern_last(a)); - run_test!(|a| slice_pattern_one_of(a, 0)); - run_test!(|a| slice_pattern_one_of(a, 1)); - run_test!(|a| slice_pattern_one_of(a, 2)); - run_test!(|a| slice_pattern_one_of(a, 3)); - - run_test!(|a| subslice_pattern_from_end(a, true)); - run_test!(|a| subslice_pattern_from_end(a, false)); - run_test!(|a| subslice_pattern_from_end_with_drop(a, true, true)); - run_test!(|a| subslice_pattern_from_end_with_drop(a, true, false)); - run_test!(|a| subslice_pattern_from_end_with_drop(a, false, true)); - run_test!(|a| subslice_pattern_from_end_with_drop(a, false, false)); - run_test!(|a| slice_pattern_reassign(a)); - run_test!(|a| subslice_pattern_reassign(a)); - - run_test!(|a| index_field_mixed_ends(a)); - run_test!(|a| subslice_mixed_min_lengths(a, 0)); - run_test!(|a| subslice_mixed_min_lengths(a, 1)); - run_test!(|a| subslice_mixed_min_lengths(a, 2)); - run_test!(|a| subslice_mixed_min_lengths(a, 3)); - run_test!(|a| subslice_mixed_min_lengths(a, 4)); - run_test!(|a| subslice_mixed_min_lengths(a, 5)); - run_test!(|a| subslice_mixed_min_lengths(a, 6)); - run_test!(|a| subslice_mixed_min_lengths(a, 7)); - - run_test!(|a| move_ref_pattern(a)); - - run_test!(|a| { + run_test(|a| dynamic_init(a, false)); + run_test(|a| dynamic_init(a, true)); + run_test(|a| dynamic_drop(a, false)); + run_test(|a| dynamic_drop(a, true)); + + run_test(|a| assignment2(a, false, false)); + run_test(|a| assignment2(a, false, true)); + run_test(|a| assignment2(a, true, false)); + run_test(|a| assignment2(a, true, true)); + + run_test(|a| assignment1(a, false)); + run_test(|a| assignment1(a, true)); + + run_test(|a| array_simple(a)); + run_test(|a| vec_simple(a)); + run_test(|a| vec_unreachable(a)); + + run_test(|a| struct_dynamic_drop(a, false, false, false)); + run_test(|a| struct_dynamic_drop(a, false, false, true)); + run_test(|a| struct_dynamic_drop(a, false, true, false)); + run_test(|a| struct_dynamic_drop(a, false, true, true)); + run_test(|a| struct_dynamic_drop(a, true, false, false)); + run_test(|a| struct_dynamic_drop(a, true, false, true)); + run_test(|a| struct_dynamic_drop(a, true, true, false)); + run_test(|a| struct_dynamic_drop(a, true, true, true)); + + run_test(|a| field_assignment(a, false)); + run_test(|a| field_assignment(a, true)); + + run_test(|a| generator(a, 0)); + run_test(|a| generator(a, 1)); + run_test(|a| generator(a, 2)); + run_test(|a| generator(a, 3)); + + run_test(|a| mixed_drop_and_nondrop(a)); + + run_test(|a| slice_pattern_first(a)); + run_test(|a| slice_pattern_middle(a)); + run_test(|a| slice_pattern_two(a)); + run_test(|a| slice_pattern_last(a)); + run_test(|a| slice_pattern_one_of(a, 0)); + run_test(|a| slice_pattern_one_of(a, 1)); + run_test(|a| slice_pattern_one_of(a, 2)); + run_test(|a| slice_pattern_one_of(a, 3)); + + run_test(|a| subslice_pattern_from_end(a, true)); + run_test(|a| subslice_pattern_from_end(a, false)); + run_test(|a| subslice_pattern_from_end_with_drop(a, true, true)); + run_test(|a| subslice_pattern_from_end_with_drop(a, true, false)); + run_test(|a| subslice_pattern_from_end_with_drop(a, false, true)); + run_test(|a| subslice_pattern_from_end_with_drop(a, false, false)); + run_test(|a| slice_pattern_reassign(a)); + run_test(|a| subslice_pattern_reassign(a)); + + run_test(|a| index_field_mixed_ends(a)); + run_test(|a| subslice_mixed_min_lengths(a, 0)); + run_test(|a| subslice_mixed_min_lengths(a, 1)); + run_test(|a| subslice_mixed_min_lengths(a, 2)); + run_test(|a| subslice_mixed_min_lengths(a, 3)); + run_test(|a| subslice_mixed_min_lengths(a, 4)); + run_test(|a| subslice_mixed_min_lengths(a, 5)); + run_test(|a| subslice_mixed_min_lengths(a, 6)); + run_test(|a| subslice_mixed_min_lengths(a, 7)); + + run_test(|a| move_ref_pattern(a)); + + run_test(|a| { panic_after_return(a); }); - run_test!(|a| { + run_test(|a| { panic_after_return_expr(a); }); - run_test!(|a| panic_after_init(a)); - run_test!(|a| panic_after_init_temp(a)); - run_test!(|a| panic_after_init_by_loop(a)); - run_test!(|a| panic_after_init_by_match(a, false)); - run_test!(|a| panic_after_init_by_match(a, true)); - run_test!(|a| panic_after_init_by_match_with_guard(a, false)); - run_test!(|a| panic_after_init_by_match_with_guard(a, true)); - run_test!(|a| panic_after_init_by_match_with_bindings_and_guard(a, false)); - run_test!(|a| panic_after_init_by_match_with_bindings_and_guard(a, true)); - run_test!(|a| panic_after_init_by_match_with_ref_bindings_and_guard(a, false)); - run_test!(|a| panic_after_init_by_match_with_ref_bindings_and_guard(a, true)); - run_test!(|a| panic_after_init_by_break_if(a, false)); - run_test!(|a| panic_after_init_by_break_if(a, true)); - - run_test!(|a| bindings_after_at_dynamic_init_move(a, true)); - run_test!(|a| bindings_after_at_dynamic_init_move(a, false)); - run_test!(|a| bindings_after_at_dynamic_init_ref(a, true)); - run_test!(|a| bindings_after_at_dynamic_init_ref(a, false)); - run_test!(|a| bindings_after_at_dynamic_drop_move(a, true)); - run_test!(|a| bindings_after_at_dynamic_drop_move(a, false)); - run_test!(|a| bindings_after_at_dynamic_drop_ref(a, true)); - run_test!(|a| bindings_after_at_dynamic_drop_ref(a, false)); - - run_test_nopanic(|a| union1(a), "|a| union1(a)"); + run_test(|a| panic_after_init(a)); + run_test(|a| panic_after_init_temp(a)); + run_test(|a| panic_after_init_by_loop(a)); + + run_test(|a| bindings_after_at_dynamic_init_move(a, true)); + run_test(|a| bindings_after_at_dynamic_init_move(a, false)); + run_test(|a| bindings_after_at_dynamic_init_ref(a, true)); + run_test(|a| bindings_after_at_dynamic_init_ref(a, false)); + run_test(|a| bindings_after_at_dynamic_drop_move(a, true)); + run_test(|a| bindings_after_at_dynamic_drop_move(a, false)); + run_test(|a| bindings_after_at_dynamic_drop_ref(a, true)); + run_test(|a| bindings_after_at_dynamic_drop_ref(a, false)); + + run_test_nopanic(|a| union1(a)); } diff --git a/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr b/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr index 05547595234..e079c2ddcee 100644 --- a/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr +++ b/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr @@ -11,7 +11,7 @@ LL | Err(#[stable(feature = "rust1", since = "1.0.0")] E), | = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html - = note: the matched value is of type `std::result::Result<u32, !>` + = note: the matched value is of type `Result<u32, !>` help: you might want to use `if let` to ignore the variant that isn't matched | LL | if let Ok(_x) = foo() { /* */ } diff --git a/src/test/ui/feature-gates/feature-gate-relaxed_struct_unsize.rs b/src/test/ui/feature-gates/feature-gate-relaxed_struct_unsize.rs new file mode 100644 index 00000000000..0cfd0a0b978 --- /dev/null +++ b/src/test/ui/feature-gates/feature-gate-relaxed_struct_unsize.rs @@ -0,0 +1,10 @@ +// Test that we allow unsizing even if there is an unchanged param in the +// field getting unsized. +struct A<T, U: ?Sized + 'static>(T, B<T, U>); +struct B<T, U: ?Sized>(T, U); + +fn main() { + let x: A<[u32; 1], [u32; 1]> = A([0; 1], B([0; 1], [0; 1])); + let y: &A<[u32; 1], [u32]> = &x; //~ ERROR mismatched types + assert_eq!(y.1.1.len(), 1); +} diff --git a/src/test/ui/feature-gates/feature-gate-relaxed_struct_unsize.stderr b/src/test/ui/feature-gates/feature-gate-relaxed_struct_unsize.stderr new file mode 100644 index 00000000000..f62def47726 --- /dev/null +++ b/src/test/ui/feature-gates/feature-gate-relaxed_struct_unsize.stderr @@ -0,0 +1,14 @@ +error[E0308]: mismatched types + --> $DIR/feature-gate-relaxed_struct_unsize.rs:8:34 + | +LL | let y: &A<[u32; 1], [u32]> = &x; + | ------------------- ^^ expected slice `[u32]`, found array `[u32; 1]` + | | + | expected due to this + | + = note: expected reference `&A<[u32; 1], [u32]>` + found reference `&A<[u32; 1], [u32; 1]>` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/feature-gates/issue-43106-gating-of-derive.rs b/src/test/ui/feature-gates/issue-43106-gating-of-derive.rs index c5d9e0db4d3..5404b8c04bb 100644 --- a/src/test/ui/feature-gates/issue-43106-gating-of-derive.rs +++ b/src/test/ui/feature-gates/issue-43106-gating-of-derive.rs @@ -6,6 +6,7 @@ mod derive { mod inner { #![derive(Debug)] } //~^ ERROR `derive` may only be applied to structs, enums and unions + //~| ERROR inner macro attributes are unstable #[derive(Debug)] //~^ ERROR `derive` may only be applied to structs, enums and unions diff --git a/src/test/ui/feature-gates/issue-43106-gating-of-derive.stderr b/src/test/ui/feature-gates/issue-43106-gating-of-derive.stderr index ffec76f409e..9b1f4f46219 100644 --- a/src/test/ui/feature-gates/issue-43106-gating-of-derive.stderr +++ b/src/test/ui/feature-gates/issue-43106-gating-of-derive.stderr @@ -4,30 +4,40 @@ error[E0774]: `derive` may only be applied to structs, enums and unions LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ +error[E0658]: inner macro attributes are unstable + --> $DIR/issue-43106-gating-of-derive.rs:7:20 + | +LL | mod inner { #![derive(Debug)] } + | ^^^^^^ + | + = note: see issue #54726 <https://github.com/rust-lang/rust/issues/54726> for more information + = help: add `#![feature(custom_inner_attributes)]` to the crate attributes to enable + error[E0774]: `derive` may only be applied to structs, enums and unions --> $DIR/issue-43106-gating-of-derive.rs:7:17 | LL | mod inner { #![derive(Debug)] } - | ^^^^^^^^^^^^^^^^^ help: try an outer attribute: `#[derive(Debug)]` + | ^^^^^^^^^^^^^^^^^ error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-43106-gating-of-derive.rs:10:5 + --> $DIR/issue-43106-gating-of-derive.rs:11:5 | LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-43106-gating-of-derive.rs:23:5 + --> $DIR/issue-43106-gating-of-derive.rs:24:5 | LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-43106-gating-of-derive.rs:27:5 + --> $DIR/issue-43106-gating-of-derive.rs:28:5 | LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ -error: aborting due to 5 previous errors +error: aborting due to 6 previous errors -For more information about this error, try `rustc --explain E0774`. +Some errors have detailed explanations: E0658, E0774. +For more information about an error, try `rustc --explain E0658`. diff --git a/src/test/ui/generator/type-mismatch-signature-deduction.stderr b/src/test/ui/generator/type-mismatch-signature-deduction.stderr index 4abc0542c51..30e23ea8f65 100644 --- a/src/test/ui/generator/type-mismatch-signature-deduction.stderr +++ b/src/test/ui/generator/type-mismatch-signature-deduction.stderr @@ -2,11 +2,11 @@ error[E0308]: mismatched types --> $DIR/type-mismatch-signature-deduction.rs:13:9 | LL | 5 - | ^ expected enum `std::result::Result`, found integer + | ^ expected enum `Result`, found integer | - = note: expected type `std::result::Result<{integer}, _>` + = note: expected type `Result<{integer}, _>` found type `{integer}` -note: return type inferred to be `std::result::Result<{integer}, _>` here +note: return type inferred to be `Result<{integer}, _>` here --> $DIR/type-mismatch-signature-deduction.rs:8:20 | LL | return Ok(6); @@ -16,9 +16,9 @@ error[E0271]: type mismatch resolving `<[generator@$DIR/type-mismatch-signature- --> $DIR/type-mismatch-signature-deduction.rs:5:13 | LL | fn foo() -> impl Generator<Return = i32> { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found `i32` + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Result`, found `i32` | - = note: expected enum `std::result::Result<{integer}, _>` + = note: expected enum `Result<{integer}, _>` found type `i32` error: aborting due to 2 previous errors diff --git a/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.rs b/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.rs new file mode 100644 index 00000000000..2c543455b6e --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.rs @@ -0,0 +1,12 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait X { + type Y<'x>; +} + +fn main() { + fn _f(arg : Box<dyn for<'a> X<Y<'x> = &'a [u32]>>) {} + //~^ ERROR: use of undeclared lifetime name `'x` + //~| ERROR: binding for associated type `Y` references lifetime +} diff --git a/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr b/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr new file mode 100644 index 00000000000..1c7c107d783 --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr @@ -0,0 +1,29 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/gat-in-trait-path-undeclared-lifetime.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0261]: use of undeclared lifetime name `'x` + --> $DIR/gat-in-trait-path-undeclared-lifetime.rs:9:35 + | +LL | fn _f(arg : Box<dyn for<'a> X<Y<'x> = &'a [u32]>>) {} + | - ^^ undeclared lifetime + | | + | help: consider introducing lifetime `'x` here: `<'x>` + | + = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes + +error[E0582]: binding for associated type `Y` references lifetime `'a`, which does not appear in the trait input types + --> $DIR/gat-in-trait-path-undeclared-lifetime.rs:9:33 + | +LL | fn _f(arg : Box<dyn for<'a> X<Y<'x> = &'a [u32]>>) {} + | ^^^^^^^^^^^^^^^^^ + +error: aborting due to 2 previous errors; 1 warning emitted + +Some errors have detailed explanations: E0261, E0582. +For more information about an error, try `rustc --explain E0261`. diff --git a/src/test/ui/generic-associated-types/gat-in-trait-path.rs b/src/test/ui/generic-associated-types/gat-in-trait-path.rs new file mode 100644 index 00000000000..2dbd1840dec --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-in-trait-path.rs @@ -0,0 +1,30 @@ +// check-pass + +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete +#![feature(associated_type_defaults)] + +trait Foo { + type A<'a> where Self: 'a; +} + +struct Fooy; + +impl Foo for Fooy { + type A<'a> = &'a (); +} + +#[derive(Clone)] +struct Fooer<T>(T); + +impl<T> Foo for Fooer<T> { + type A<'x> where T: 'x = &'x (); +} + +fn f(_arg : Box<dyn for<'a> Foo<A<'a> = &'a ()>>) {} + + +fn main() { + let foo = Fooer(5); + f(Box::new(foo)); +} diff --git a/src/test/ui/generic-associated-types/gat-in-trait-path.stderr b/src/test/ui/generic-associated-types/gat-in-trait-path.stderr new file mode 100644 index 00000000000..f3769827f04 --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-in-trait-path.stderr @@ -0,0 +1,11 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/gat-in-trait-path.rs:3:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +warning: 1 warning emitted + diff --git a/src/test/ui/generic-associated-types/gat-trait-path-generic-type-arg.rs b/src/test/ui/generic-associated-types/gat-trait-path-generic-type-arg.rs new file mode 100644 index 00000000000..cff5a21052f --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-trait-path-generic-type-arg.rs @@ -0,0 +1,16 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait Foo { + type F<'a>; + + fn identity<'a>(t: &'a Self::F<'a>) -> &'a Self::F<'a> { t } +} + +impl <T, T1> Foo for T { + type F<T1> = &[u8]; + //~^ ERROR: the name `T1` is already used for + //~| ERROR: missing lifetime specifier +} + +fn main() {} diff --git a/src/test/ui/generic-associated-types/gat-trait-path-generic-type-arg.stderr b/src/test/ui/generic-associated-types/gat-trait-path-generic-type-arg.stderr new file mode 100644 index 00000000000..e83af1d0c73 --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-trait-path-generic-type-arg.stderr @@ -0,0 +1,32 @@ +error[E0403]: the name `T1` is already used for a generic parameter in this item's generic parameters + --> $DIR/gat-trait-path-generic-type-arg.rs:11:12 + | +LL | impl <T, T1> Foo for T { + | -- first use of `T1` +LL | type F<T1> = &[u8]; + | ^^ already used + +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/gat-trait-path-generic-type-arg.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0106]: missing lifetime specifier + --> $DIR/gat-trait-path-generic-type-arg.rs:11:18 + | +LL | type F<T1> = &[u8]; + | ^ expected named lifetime parameter + | +help: consider introducing a named lifetime parameter + | +LL | type F<'a, T1> = &'a [u8]; + | ^^^ ^^^ + +error: aborting due to 2 previous errors; 1 warning emitted + +Some errors have detailed explanations: E0106, E0403. +For more information about an error, try `rustc --explain E0106`. diff --git a/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs new file mode 100644 index 00000000000..e69e355ba48 --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs @@ -0,0 +1,18 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait X { + type Y<'a>; + //~^ ERROR missing generics for + //~| ERROR missing generics for + + fn foo<'a>(t : Self::Y<'a>) -> Self::Y<'a> { t } +} + +impl<T> X for T { + fn foo<'a, T1: X<Y = T1>>(t : T1) -> T1::Y<'a> { + t + } +} + +fn main() {} diff --git a/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.stderr b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.stderr new file mode 100644 index 00000000000..9c6e2ce3e17 --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.stderr @@ -0,0 +1,44 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/gat-trait-path-missing-lifetime.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0107]: missing generics for associated type `X::Y` + --> $DIR/gat-trait-path-missing-lifetime.rs:5:8 + | +LL | type Y<'a>; + | ^ expected 1 lifetime argument + | +note: associated type defined here, with 1 lifetime parameter: `'a` + --> $DIR/gat-trait-path-missing-lifetime.rs:5:8 + | +LL | type Y<'a>; + | ^ -- +help: use angle brackets to add missing lifetime argument + | +LL | type Y<'a><'a>; + | ^^^^ + +error[E0107]: missing generics for associated type `X::Y` + --> $DIR/gat-trait-path-missing-lifetime.rs:5:8 + | +LL | type Y<'a>; + | ^ expected 1 lifetime argument + | +note: associated type defined here, with 1 lifetime parameter: `'a` + --> $DIR/gat-trait-path-missing-lifetime.rs:5:8 + | +LL | type Y<'a>; + | ^ -- +help: use angle brackets to add missing lifetime argument + | +LL | type Y<'a><'a>; + | ^^^^ + +error: aborting due to 2 previous errors; 1 warning emitted + +For more information about this error, try `rustc --explain E0107`. diff --git a/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.rs b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.rs new file mode 100644 index 00000000000..bb1f27a17ca --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.rs @@ -0,0 +1,15 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait X { + type Y<'a>; + //~^ ERROR this associated type + //~| ERROR this associated type +} + +fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {} + //~^ ERROR: lifetime in trait object type must be followed by `+` + //~| ERROR: parenthesized generic arguments cannot be used + //~| WARNING: trait objects without an explicit `dyn` are deprecated + +fn main() {} diff --git a/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.stderr b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.stderr new file mode 100644 index 00000000000..20cb6d88287 --- /dev/null +++ b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.stderr @@ -0,0 +1,68 @@ +error: lifetime in trait object type must be followed by `+` + --> $DIR/gat-trait-path-parenthesised-args.rs:10:29 + | +LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {} + | ^^ + +error: parenthesized generic arguments cannot be used in associated type constraints + --> $DIR/gat-trait-path-parenthesised-args.rs:10:27 + | +LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {} + | ^^^^^ + +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/gat-trait-path-parenthesised-args.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +warning: trait objects without an explicit `dyn` are deprecated + --> $DIR/gat-trait-path-parenthesised-args.rs:10:29 + | +LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {} + | ^^ help: use `dyn`: `dyn 'a` + | + = note: `#[warn(bare_trait_objects)]` on by default + +error[E0107]: this associated type takes 1 lifetime argument but 0 lifetime arguments were supplied + --> $DIR/gat-trait-path-parenthesised-args.rs:5:8 + | +LL | type Y<'a>; + | ^ expected 1 lifetime argument + | +note: associated type defined here, with 1 lifetime parameter: `'a` + --> $DIR/gat-trait-path-parenthesised-args.rs:5:8 + | +LL | type Y<'a>; + | ^ -- +help: add missing lifetime argument + | +LL | fn foo<'a>(arg: Box<dyn X<Y('a'a) = &'a ()>>) {} + | ^^ + +error[E0107]: this associated type takes 0 type arguments but 1 type argument was supplied + --> $DIR/gat-trait-path-parenthesised-args.rs:5:8 + | +LL | type Y<'a>; + | ________^- + | | | + | | expected 0 type arguments +LL | | +LL | | +LL | | } +LL | | +LL | | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {} + | |_________________________________________- help: remove these generics + | +note: associated type defined here, with 0 type parameters + --> $DIR/gat-trait-path-parenthesised-args.rs:5:8 + | +LL | type Y<'a>; + | ^ + +error: aborting due to 4 previous errors; 2 warnings emitted + +For more information about this error, try `rustc --explain E0107`. diff --git a/src/test/ui/generic-associated-types/issue-67510-pass.rs b/src/test/ui/generic-associated-types/issue-67510-pass.rs new file mode 100644 index 00000000000..ff38b3e93eb --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-67510-pass.rs @@ -0,0 +1,12 @@ +// check-pass + +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait X { + type Y<'a>; +} + +fn _func1<'a>(_x: Box<dyn X<Y<'a>=&'a ()>>) {} + +fn main() {} diff --git a/src/test/ui/generic-associated-types/issue-67510-pass.stderr b/src/test/ui/generic-associated-types/issue-67510-pass.stderr new file mode 100644 index 00000000000..0fbf704df76 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-67510-pass.stderr @@ -0,0 +1,11 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-67510-pass.rs:3:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +warning: 1 warning emitted + diff --git a/src/test/ui/generic-associated-types/issue-67510.rs b/src/test/ui/generic-associated-types/issue-67510.rs new file mode 100644 index 00000000000..62b22089f91 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-67510.rs @@ -0,0 +1,13 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait X { + type Y<'a>; +} + +fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {} + //~^ ERROR: use of undeclared lifetime name `'a` + //~| ERROR: use of undeclared lifetime name `'a` + + +fn main() {} diff --git a/src/test/ui/generic-associated-types/issue-67510.stderr b/src/test/ui/generic-associated-types/issue-67510.stderr new file mode 100644 index 00000000000..12755c56974 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-67510.stderr @@ -0,0 +1,32 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-67510.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0261]: use of undeclared lifetime name `'a` + --> $DIR/issue-67510.rs:8:21 + | +LL | fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {} + | - ^^ undeclared lifetime + | | + | help: consider introducing lifetime `'a` here: `<'a>` + | + = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes + +error[E0261]: use of undeclared lifetime name `'a` + --> $DIR/issue-67510.rs:8:26 + | +LL | fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {} + | - ^^ undeclared lifetime + | | + | help: consider introducing lifetime `'a` here: `<'a>` + | + = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes + +error: aborting due to 2 previous errors; 1 warning emitted + +For more information about this error, try `rustc --explain E0261`. diff --git a/src/test/ui/generic-associated-types/issue-68648-1.rs b/src/test/ui/generic-associated-types/issue-68648-1.rs new file mode 100644 index 00000000000..f294b22f73c --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-68648-1.rs @@ -0,0 +1,26 @@ +// check-pass + +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + + +trait Fun { + type F<'a>; + + fn identity<'a>(t: Self::F<'a>) -> Self::F<'a> { t } +} + +impl <T> Fun for T { + type F<'a> = Self; +} + +fn bug<'a, T: for<'b> Fun<F<'b> = T>>(t: T) -> T::F<'a> { + T::identity(t) +} + + +fn main() { + let x = 10; + + bug(x); +} diff --git a/src/test/ui/generic-associated-types/issue-68648-1.stderr b/src/test/ui/generic-associated-types/issue-68648-1.stderr new file mode 100644 index 00000000000..322a8f9e13f --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-68648-1.stderr @@ -0,0 +1,11 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-68648-1.rs:3:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +warning: 1 warning emitted + diff --git a/src/test/ui/generic-associated-types/issue-68648-2.rs b/src/test/ui/generic-associated-types/issue-68648-2.rs new file mode 100644 index 00000000000..e55bfcd4ba2 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-68648-2.rs @@ -0,0 +1,24 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait Fun { + type F<'a>; + + fn identity<'a>(t: Self::F<'a>) -> Self::F<'a> { t } +} + +impl <T> Fun for T { + type F<'a> = Self; +} + +fn bug<'a, T: Fun<F<'a> = T>>(t: T) -> T::F<'a> { + T::identity(()) + //~^ ERROR: mismatched types +} + + +fn main() { + let x = 10; + + bug(x); +} diff --git a/src/test/ui/generic-associated-types/issue-68648-2.stderr b/src/test/ui/generic-associated-types/issue-68648-2.stderr new file mode 100644 index 00000000000..b51e0bca9f7 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-68648-2.stderr @@ -0,0 +1,23 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-68648-2.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0308]: mismatched types + --> $DIR/issue-68648-2.rs:15:17 + | +LL | fn bug<'a, T: Fun<F<'a> = T>>(t: T) -> T::F<'a> { + | - this type parameter +LL | T::identity(()) + | ^^ expected type parameter `T`, found `()` + | + = note: expected type parameter `T` + found unit type `()` + +error: aborting due to previous error; 1 warning emitted + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/generic-associated-types/issue-68649-pass.rs b/src/test/ui/generic-associated-types/issue-68649-pass.rs new file mode 100644 index 00000000000..396315302f7 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-68649-pass.rs @@ -0,0 +1,25 @@ +// check-pass + +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait Fun { + type F<'a>; + + fn identity<'a>(t: Self::F<'a>) -> Self::F<'a> { t } +} + +impl <T> Fun for T { + type F<'a> = Self; +} + +fn bug<'a, T: Fun<F<'a> = T>>(t: T) -> T::F<'a> { + T::identity(t) +} + + +fn main() { + let x = 10; + + bug(x); +} diff --git a/src/test/ui/generic-associated-types/issue-68649-pass.stderr b/src/test/ui/generic-associated-types/issue-68649-pass.stderr new file mode 100644 index 00000000000..e4a2f8d2a64 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-68649-pass.stderr @@ -0,0 +1,11 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-68649-pass.rs:3:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +warning: 1 warning emitted + diff --git a/src/test/ui/generic-associated-types/issue-74684-1.rs b/src/test/ui/generic-associated-types/issue-74684-1.rs new file mode 100644 index 00000000000..a483da863ff --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-74684-1.rs @@ -0,0 +1,26 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait Fun { + type F<'a>: ?Sized; + + fn identity<'a>(t: &'a Self::F<'a>) -> &'a Self::F<'a> { t } +} + +impl <T> Fun for T { + type F<'a> = [u8]; +} + +fn bug<'a, T: ?Sized + Fun<F<'a> = [u8]>>(_ : Box<T>) -> &'static T::F<'a> { + let a = [0; 1]; + let _x = T::identity(&a); + //~^ ERROR: `a` does not live long enough + todo!() +} + + +fn main() { + let x = 10; + + bug(Box::new(x)); +} diff --git a/src/test/ui/generic-associated-types/issue-74684-1.stderr b/src/test/ui/generic-associated-types/issue-74684-1.stderr new file mode 100644 index 00000000000..651da696827 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-74684-1.stderr @@ -0,0 +1,27 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-74684-1.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0597]: `a` does not live long enough + --> $DIR/issue-74684-1.rs:16:26 + | +LL | fn bug<'a, T: ?Sized + Fun<F<'a> = [u8]>>(_ : Box<T>) -> &'static T::F<'a> { + | -- lifetime `'a` defined here +LL | let a = [0; 1]; +LL | let _x = T::identity(&a); + | ------------^^- + | | | + | | borrowed value does not live long enough + | argument requires that `a` is borrowed for `'a` +... +LL | } + | - `a` dropped here while still borrowed + +error: aborting due to previous error; 1 warning emitted + +For more information about this error, try `rustc --explain E0597`. diff --git a/src/test/ui/generic-associated-types/issue-74684-2.rs b/src/test/ui/generic-associated-types/issue-74684-2.rs new file mode 100644 index 00000000000..0caf19cb030 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-74684-2.rs @@ -0,0 +1,26 @@ +#![feature(generic_associated_types)] + //~^ WARNING: the feature `generic_associated_types` is incomplete + +trait Fun { + type F<'a>: ?Sized; + + fn identity<'a>(t: &'a Self::F<'a>) -> &'a Self::F<'a> { t } +} + +impl <T> Fun for T { + type F<'a> = i32; +} + +fn bug<'a, T: ?Sized + Fun<F<'a> = [u8]>>(t: Box<T>) -> &'static T::F<'a> { + let a = [0; 1]; + let x = T::identity(&a); + todo!() +} + + +fn main() { + let x = 10; + + bug(Box::new(x)); + //~^ ERROR: type mismatch resolving `<{integer} as Fun>::F<'_> == [u8]` +} diff --git a/src/test/ui/generic-associated-types/issue-74684-2.stderr b/src/test/ui/generic-associated-types/issue-74684-2.stderr new file mode 100644 index 00000000000..8c3484f9a73 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-74684-2.stderr @@ -0,0 +1,21 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-74684-2.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0271]: type mismatch resolving `<{integer} as Fun>::F<'_> == [u8]` + --> $DIR/issue-74684-2.rs:24:5 + | +LL | fn bug<'a, T: ?Sized + Fun<F<'a> = [u8]>>(t: Box<T>) -> &'static T::F<'a> { + | ------------ required by this bound in `bug` +... +LL | bug(Box::new(x)); + | ^^^ expected slice `[u8]`, found `i32` + +error: aborting due to previous error; 1 warning emitted + +For more information about this error, try `rustc --explain E0271`. diff --git a/src/test/ui/generic-associated-types/issue-76535.rs b/src/test/ui/generic-associated-types/issue-76535.rs new file mode 100644 index 00000000000..2b4757d8d15 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-76535.rs @@ -0,0 +1,41 @@ +#![feature(generic_associated_types)] + //~^ WARNING the feature + +pub trait SubTrait {} + +pub trait SuperTrait { + type SubType<'a>: SubTrait; + //~^ ERROR missing generics for associated + + fn get_sub<'a>(&'a mut self) -> Self::SubType<'a>; +} + +pub struct SubStruct<'a> { + sup: &'a mut SuperStruct, +} + +impl<'a> SubTrait for SubStruct<'a> {} + +pub struct SuperStruct { + value: u8, +} + +impl SuperStruct { + pub fn new(value: u8) -> SuperStruct { + SuperStruct { value } + } +} + +impl SuperTrait for SuperStruct { + type SubType<'a> = SubStruct<'a>; + + fn get_sub<'a>(&'a mut self) -> Self::SubType<'a> { + SubStruct { sup: self } + } +} + +fn main() { + let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0)); + //~^ ERROR the trait + //~| ERROR the trait +} diff --git a/src/test/ui/generic-associated-types/issue-76535.stderr b/src/test/ui/generic-associated-types/issue-76535.stderr new file mode 100644 index 00000000000..ce4875af9c0 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-76535.stderr @@ -0,0 +1,63 @@ +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/issue-76535.rs:1:12 + | +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0107]: missing generics for associated type `SuperTrait::SubType` + --> $DIR/issue-76535.rs:7:10 + | +LL | type SubType<'a>: SubTrait; + | ^^^^^^^ expected 1 lifetime argument + | +note: associated type defined here, with 1 lifetime parameter: `'a` + --> $DIR/issue-76535.rs:7:10 + | +LL | type SubType<'a>: SubTrait; + | ^^^^^^^ -- +help: use angle brackets to add missing lifetime argument + | +LL | type SubType<'a><'a>: SubTrait; + | ^^^^ + +error[E0038]: the trait `SuperTrait` cannot be made into an object + --> $DIR/issue-76535.rs:38:14 + | +LL | let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `SuperTrait` cannot be made into an object + | + = help: consider moving `get_sub` to another trait +note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> + --> $DIR/issue-76535.rs:10:37 + | +LL | pub trait SuperTrait { + | ---------- this trait cannot be made into an object... +... +LL | fn get_sub<'a>(&'a mut self) -> Self::SubType<'a>; + | ^^^^^^^^^^^^^^^^^ ...because method `get_sub` references the `Self` type in its return type + +error[E0038]: the trait `SuperTrait` cannot be made into an object + --> $DIR/issue-76535.rs:38:57 + | +LL | let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `SuperTrait` cannot be made into an object + | + = help: consider moving `get_sub` to another trait +note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> + --> $DIR/issue-76535.rs:10:37 + | +LL | pub trait SuperTrait { + | ---------- this trait cannot be made into an object... +... +LL | fn get_sub<'a>(&'a mut self) -> Self::SubType<'a>; + | ^^^^^^^^^^^^^^^^^ ...because method `get_sub` references the `Self` type in its return type + = note: required because of the requirements on the impl of `CoerceUnsized<Box<dyn SuperTrait<SubType = SubStruct<'_>>>>` for `Box<SuperStruct>` + = note: required by cast to type `Box<dyn SuperTrait<SubType = SubStruct<'_>>>` + +error: aborting due to 3 previous errors; 1 warning emitted + +Some errors have detailed explanations: E0038, E0107. +For more information about an error, try `rustc --explain E0038`. diff --git a/src/test/ui/generic-associated-types/issue-79422.rs b/src/test/ui/generic-associated-types/issue-79422.rs new file mode 100644 index 00000000000..26b38430dd9 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-79422.rs @@ -0,0 +1,47 @@ +#![allow(incomplete_features)] +#![feature(generic_associated_types)] + +trait RefCont<'a, T> { + fn t(&'a self) -> &'a T; +} + +impl<'a, T> RefCont<'a, T> for &'a T { + fn t(&'a self) -> &'a T { + self + } +} + +impl<'a, T> RefCont<'a, T> for Box<T> { + fn t(&'a self) -> &'a T { + self.as_ref() + } +} + +trait MapLike<K, V> { + type VRefCont<'a>: RefCont<'a, V>; + //~^ ERROR missing generics + fn get<'a>(&'a self, key: &K) -> Option<Self::VRefCont<'a>>; +} + +impl<K: Ord, V: 'static> MapLike<K, V> for std::collections::BTreeMap<K, V> { + type VRefCont<'a> = &'a V; + fn get<'a>(&'a self, key: &K) -> Option<&'a V> { + std::collections::BTreeMap::get(self, key) + } +} + +struct Source; + +impl<K, V: Default> MapLike<K, V> for Source { + type VRefCont<'a> = Box<V>; + fn get<'a>(&self, _: &K) -> Option<Box<V>> { + Some(Box::new(V::default())) + } +} + +fn main() { + let m = Box::new(std::collections::BTreeMap::<u8, u8>::new()) + as Box<dyn MapLike<u8, u8, VRefCont = dyn RefCont<'_, u8>>>; + //~^ ERROR the trait + //~^^^ ERROR the trait +} diff --git a/src/test/ui/generic-associated-types/issue-79422.stderr b/src/test/ui/generic-associated-types/issue-79422.stderr new file mode 100644 index 00000000000..d2e12962715 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-79422.stderr @@ -0,0 +1,54 @@ +error[E0107]: missing generics for associated type `MapLike::VRefCont` + --> $DIR/issue-79422.rs:21:10 + | +LL | type VRefCont<'a>: RefCont<'a, V>; + | ^^^^^^^^ expected 1 lifetime argument + | +note: associated type defined here, with 1 lifetime parameter: `'a` + --> $DIR/issue-79422.rs:21:10 + | +LL | type VRefCont<'a>: RefCont<'a, V>; + | ^^^^^^^^ -- +help: use angle brackets to add missing lifetime argument + | +LL | type VRefCont<'a><'a>: RefCont<'a, V>; + | ^^^^ + +error[E0038]: the trait `MapLike` cannot be made into an object + --> $DIR/issue-79422.rs:44:12 + | +LL | as Box<dyn MapLike<u8, u8, VRefCont = dyn RefCont<'_, u8>>>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `MapLike` cannot be made into an object + | + = help: consider moving `get` to another trait +note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> + --> $DIR/issue-79422.rs:23:38 + | +LL | trait MapLike<K, V> { + | ------- this trait cannot be made into an object... +... +LL | fn get<'a>(&'a self, key: &K) -> Option<Self::VRefCont<'a>>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ...because method `get` references the `Self` type in its return type + +error[E0038]: the trait `MapLike` cannot be made into an object + --> $DIR/issue-79422.rs:43:13 + | +LL | let m = Box::new(std::collections::BTreeMap::<u8, u8>::new()) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `MapLike` cannot be made into an object + | + = help: consider moving `get` to another trait +note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> + --> $DIR/issue-79422.rs:23:38 + | +LL | trait MapLike<K, V> { + | ------- this trait cannot be made into an object... +... +LL | fn get<'a>(&'a self, key: &K) -> Option<Self::VRefCont<'a>>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ ...because method `get` references the `Self` type in its return type + = note: required because of the requirements on the impl of `CoerceUnsized<Box<dyn MapLike<u8, u8, VRefCont = (dyn RefCont<'_, u8> + 'static)>>>` for `Box<BTreeMap<u8, u8>>` + = note: required by cast to type `Box<dyn MapLike<u8, u8, VRefCont = (dyn RefCont<'_, u8> + 'static)>>` + +error: aborting due to 3 previous errors + +Some errors have detailed explanations: E0038, E0107. +For more information about an error, try `rustc --explain E0038`. diff --git a/src/test/ui/generic-associated-types/issue-80433-reduced.rs b/src/test/ui/generic-associated-types/issue-80433-reduced.rs new file mode 100644 index 00000000000..7c1673edc51 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-80433-reduced.rs @@ -0,0 +1,24 @@ +// check-pass + +#![allow(incomplete_features)] +#![feature(generic_associated_types)] + +struct E {} + +trait TestMut { + type Output<'a>; + fn test_mut(&mut self) -> Self::Output<'static>; +} + +impl TestMut for E { + type Output<'a> = usize; + fn test_mut(&mut self) -> Self::Output<'static> { + todo!() + } +} + +fn test_simpler<'a>(_: impl TestMut<Output<'a> = usize>) {} + +fn main() { + test_simpler(E {}); +} diff --git a/src/test/ui/generic-associated-types/issue-80433.rs b/src/test/ui/generic-associated-types/issue-80433.rs new file mode 100644 index 00000000000..ea65f05de23 --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-80433.rs @@ -0,0 +1,35 @@ +#![feature(generic_associated_types)] +#![allow(incomplete_features)] + +#[derive(Default)] +struct E<T> { + data: T, +} + +trait TestMut { + type Output<'a>; + //~^ ERROR missing generics + fn test_mut<'a>(&'a mut self) -> Self::Output<'a>; +} + +impl<T> TestMut for E<T> +where + T: 'static, +{ + type Output<'a> = &'a mut T; + fn test_mut<'a>(&'a mut self) -> Self::Output<'a> { + &mut self.data + } +} + +fn test_simpler<'a>(dst: &'a mut impl TestMut<Output = &'a mut f32>) +{ + for n in 0i16..100 { + *dst.test_mut() = n.into(); + } +} + +fn main() { + let mut t1: E<f32> = Default::default(); + test_simpler(&mut t1); +} diff --git a/src/test/ui/generic-associated-types/issue-80433.stderr b/src/test/ui/generic-associated-types/issue-80433.stderr new file mode 100644 index 00000000000..5398920fafd --- /dev/null +++ b/src/test/ui/generic-associated-types/issue-80433.stderr @@ -0,0 +1,19 @@ +error[E0107]: missing generics for associated type `TestMut::Output` + --> $DIR/issue-80433.rs:10:10 + | +LL | type Output<'a>; + | ^^^^^^ expected 1 lifetime argument + | +note: associated type defined here, with 1 lifetime parameter: `'a` + --> $DIR/issue-80433.rs:10:10 + | +LL | type Output<'a>; + | ^^^^^^ -- +help: use angle brackets to add missing lifetime argument + | +LL | type Output<'a><'a>; + | ^^^^ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0107`. diff --git a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs index e203a5e0d2d..2d38770bcdf 100644 --- a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs +++ b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs @@ -1,10 +1,14 @@ #![feature(generic_associated_types)] + //~^ the feature `generic_associated_types` is incomplete trait X { type Y<'a>; + //~^ ERROR this associated type + //~| ERROR this associated type } const _: () = { fn f2<'a>(arg : Box<dyn X<Y<1> = &'a ()>>) {} - //~^ ERROR: generic associated types in trait paths are currently not implemented }; + +fn main() {} diff --git a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr index e59a72a99ee..60b8fb9bcaa 100644 --- a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr +++ b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr @@ -1,8 +1,49 @@ -error: generic associated types in trait paths are currently not implemented - --> $DIR/trait-path-type-error-once-implemented.rs:8:30 +warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes + --> $DIR/trait-path-type-error-once-implemented.rs:1:12 | -LL | fn f2<'a>(arg : Box<dyn X<Y<1> = &'a ()>>) {} - | ^^^ +LL | #![feature(generic_associated_types)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(incomplete_features)]` on by default + = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information + +error[E0107]: this associated type takes 1 lifetime argument but 0 lifetime arguments were supplied + --> $DIR/trait-path-type-error-once-implemented.rs:5:10 + | +LL | type Y<'a>; + | ^ expected 1 lifetime argument + | +note: associated type defined here, with 1 lifetime parameter: `'a` + --> $DIR/trait-path-type-error-once-implemented.rs:5:10 + | +LL | type Y<'a>; + | ^ -- +help: add missing lifetime argument + | +LL | fn f2<'a>(arg : Box<dyn X<Y<'a1> = &'a ()>>) {} + | ^^ + +error[E0107]: this associated type takes 0 const arguments but 1 const argument was supplied + --> $DIR/trait-path-type-error-once-implemented.rs:5:10 + | +LL | type Y<'a>; + | __________^- + | | | + | | expected 0 const arguments +LL | | +LL | | +LL | | } +LL | | +LL | | const _: () = { +LL | | fn f2<'a>(arg : Box<dyn X<Y<1> = &'a ()>>) {} + | |________________________________- help: remove these generics + | +note: associated type defined here, with 0 const parameters + --> $DIR/trait-path-type-error-once-implemented.rs:5:10 + | +LL | type Y<'a>; + | ^ -error: aborting due to previous error +error: aborting due to 2 previous errors; 1 warning emitted +For more information about this error, try `rustc --explain E0107`. diff --git a/src/test/ui/generic-associated-types/parse/trait-path-unimplemented.rs b/src/test/ui/generic-associated-types/parse/trait-path-unimplemented.rs deleted file mode 100644 index 02d53d5faee..00000000000 --- a/src/test/ui/generic-associated-types/parse/trait-path-unimplemented.rs +++ /dev/null @@ -1,17 +0,0 @@ -#![feature(generic_associated_types)] - -trait X { - type Y<'a>; -} - -const _: () = { - fn f1<'a>(arg : Box<dyn X<Y<'a> = &'a ()>>) {} - //~^ ERROR: generic associated types in trait paths are currently not implemented -}; - -const _: () = { - fn f1<'a>(arg : Box<dyn X<Y('a) = &'a ()>>) {} - //~^ ERROR: lifetime in trait object type must be followed by `+` -}; - -fn main() {} diff --git a/src/test/ui/generic-associated-types/parse/trait-path-unimplemented.stderr b/src/test/ui/generic-associated-types/parse/trait-path-unimplemented.stderr deleted file mode 100644 index 1fba9cebd24..00000000000 --- a/src/test/ui/generic-associated-types/parse/trait-path-unimplemented.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error: lifetime in trait object type must be followed by `+` - --> $DIR/trait-path-unimplemented.rs:13:31 - | -LL | fn f1<'a>(arg : Box<dyn X<Y('a) = &'a ()>>) {} - | ^^ - -error: generic associated types in trait paths are currently not implemented - --> $DIR/trait-path-unimplemented.rs:8:30 - | -LL | fn f1<'a>(arg : Box<dyn X<Y<'a> = &'a ()>>) {} - | ^^^^ - -error: aborting due to 2 previous errors - diff --git a/src/test/ui/generics/wrong-number-of-args.rs b/src/test/ui/generics/wrong-number-of-args.rs index 6b99865202e..2994ca3c759 100644 --- a/src/test/ui/generics/wrong-number-of-args.rs +++ b/src/test/ui/generics/wrong-number-of-args.rs @@ -139,7 +139,7 @@ mod stdlib { mod result { type A = Result; - //~^ ERROR missing generics for enum `std::result::Result` + //~^ ERROR missing generics for enum `Result` //~| HELP use angle brackets type B = Result<String>; diff --git a/src/test/ui/generics/wrong-number-of-args.stderr b/src/test/ui/generics/wrong-number-of-args.stderr index 2a34fba2c48..73bd76aa5fa 100644 --- a/src/test/ui/generics/wrong-number-of-args.stderr +++ b/src/test/ui/generics/wrong-number-of-args.stderr @@ -365,7 +365,7 @@ note: struct defined here, with at most 3 type parameters: `K`, `V`, `S` LL | pub struct HashMap<K, V, S = RandomState> { | ^^^^^^^ - - - -error[E0107]: missing generics for enum `std::result::Result` +error[E0107]: missing generics for enum `Result` --> $DIR/wrong-number-of-args.rs:141:18 | LL | type A = Result; diff --git a/src/test/ui/impl-trait/trait_type.stderr b/src/test/ui/impl-trait/trait_type.stderr index e94f2c70215..961bb735118 100644 --- a/src/test/ui/impl-trait/trait_type.stderr +++ b/src/test/ui/impl-trait/trait_type.stderr @@ -4,7 +4,7 @@ error[E0053]: method `fmt` has an incompatible type for trait LL | fn fmt(&self, x: &str) -> () { } | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability | - = note: expected fn pointer `fn(&MyType, &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error>` + = note: expected fn pointer `fn(&MyType, &mut Formatter<'_>) -> Result<(), std::fmt::Error>` found fn pointer `fn(&MyType, &str)` error[E0050]: method `fmt` has 1 parameter but the declaration in trait `std::fmt::Display::fmt` has 2 @@ -13,7 +13,7 @@ error[E0050]: method `fmt` has 1 parameter but the declaration in trait `std::fm LL | fn fmt(&self) -> () { } | ^^^^^ expected 2 parameters, found 1 | - = note: `fmt` from trait: `fn(&Self, &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error>` + = note: `fmt` from trait: `fn(&Self, &mut Formatter<'_>) -> Result<(), std::fmt::Error>` error[E0186]: method `fmt` has a `&self` declaration in the trait, but not in the impl --> $DIR/trait_type.rs:17:4 @@ -21,7 +21,7 @@ error[E0186]: method `fmt` has a `&self` declaration in the trait, but not in th LL | fn fmt() -> () { } | ^^^^^^^^^^^^^^ expected `&self` in impl | - = note: `fmt` from trait: `fn(&Self, &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error>` + = note: `fmt` from trait: `fn(&Self, &mut Formatter<'_>) -> Result<(), std::fmt::Error>` error[E0046]: not all trait items implemented, missing: `fmt` --> $DIR/trait_type.rs:21:1 @@ -29,7 +29,7 @@ error[E0046]: not all trait items implemented, missing: `fmt` LL | impl std::fmt::Display for MyType4 {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `fmt` in implementation | - = help: implement the missing item: `fn fmt(&self, _: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { todo!() }` + = help: implement the missing item: `fn fmt(&self, _: &mut Formatter<'_>) -> Result<(), std::fmt::Error> { todo!() }` error: aborting due to 4 previous errors diff --git a/src/test/ui/inference/cannot-infer-closure-circular.stderr b/src/test/ui/inference/cannot-infer-closure-circular.stderr index 5efb400a4c7..211ae13e46d 100644 --- a/src/test/ui/inference/cannot-infer-closure-circular.stderr +++ b/src/test/ui/inference/cannot-infer-closure-circular.stderr @@ -1,8 +1,8 @@ -error[E0282]: type annotations needed for `std::result::Result<(), E>` +error[E0282]: type annotations needed for `Result<(), E>` --> $DIR/cannot-infer-closure-circular.rs:7:14 | LL | let x = |r| { - | ^ consider giving this closure parameter the explicit type `std::result::Result<(), E>`, with the type parameters specified + | ^ consider giving this closure parameter the explicit type `Result<(), E>`, with the type parameters specified error: aborting due to previous error diff --git a/src/test/ui/inference/cannot-infer-closure.stderr b/src/test/ui/inference/cannot-infer-closure.stderr index 475ed00d107..0dcce9e990b 100644 --- a/src/test/ui/inference/cannot-infer-closure.stderr +++ b/src/test/ui/inference/cannot-infer-closure.stderr @@ -1,4 +1,4 @@ -error[E0282]: type annotations needed for the closure `fn((), ()) -> std::result::Result<(), _>` +error[E0282]: type annotations needed for the closure `fn((), ()) -> Result<(), _>` --> $DIR/cannot-infer-closure.rs:3:15 | LL | Err(a)?; @@ -7,8 +7,8 @@ LL | Err(a)?; = note: `?` implicitly converts the error value into a type implementing `From<()>` help: give this closure an explicit return type without `_` placeholders | -LL | let x = |a: (), b: ()| -> std::result::Result<(), _> { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | let x = |a: (), b: ()| -> Result<(), _> { + | ^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/inference/cannot-infer-partial-try-return.stderr b/src/test/ui/inference/cannot-infer-partial-try-return.stderr index a64503fa667..86e2126e1ae 100644 --- a/src/test/ui/inference/cannot-infer-partial-try-return.stderr +++ b/src/test/ui/inference/cannot-infer-partial-try-return.stderr @@ -1,4 +1,4 @@ -error[E0282]: type annotations needed for the closure `fn() -> std::result::Result<(), QualifiedError<_>>` +error[E0282]: type annotations needed for the closure `fn() -> Result<(), QualifiedError<_>>` --> $DIR/cannot-infer-partial-try-return.rs:19:9 | LL | infallible()?; @@ -7,8 +7,8 @@ LL | infallible()?; = note: `?` implicitly converts the error value into `QualifiedError<_>` using its implementation of `From<Infallible>` help: give this closure an explicit return type without `_` placeholders | -LL | let x = || -> std::result::Result<(), QualifiedError<_>> { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | let x = || -> Result<(), QualifiedError<_>> { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/inference/issue-72616.stderr b/src/test/ui/inference/issue-72616.stderr index d811988c9c1..3c9d864c426 100644 --- a/src/test/ui/inference/issue-72616.stderr +++ b/src/test/ui/inference/issue-72616.stderr @@ -2,7 +2,7 @@ error[E0283]: type annotations needed --> $DIR/issue-72616.rs:20:30 | LL | if String::from("a") == "a".try_into().unwrap() {} - | ^^ -------------- this method call resolves to `std::result::Result<T, <Self as TryInto<T>>::Error>` + | ^^ -------------- this method call resolves to `Result<T, <Self as TryInto<T>>::Error>` | | | cannot infer type | diff --git a/src/test/ui/issue-74047.stderr b/src/test/ui/issue-74047.stderr index 8f7c91a78d8..28174825d8b 100644 --- a/src/test/ui/issue-74047.stderr +++ b/src/test/ui/issue-74047.stderr @@ -5,7 +5,7 @@ LL | impl TryFrom<OtherStream> for MyStream {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `Error`, `try_from` in implementation | = help: implement the missing item: `type Error = Type;` - = help: implement the missing item: `fn try_from(_: T) -> std::result::Result<Self, <Self as TryFrom<T>>::Error> { todo!() }` + = help: implement the missing item: `fn try_from(_: T) -> Result<Self, <Self as TryFrom<T>>::Error> { todo!() }` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-11844.stderr b/src/test/ui/issues/issue-11844.stderr index 00eecbc9a98..9d7470e7af9 100644 --- a/src/test/ui/issues/issue-11844.stderr +++ b/src/test/ui/issues/issue-11844.stderr @@ -4,10 +4,10 @@ error[E0308]: mismatched types LL | match a { | - this expression has type `Option<Box<{integer}>>` LL | Ok(a) => - | ^^^^^ expected enum `Option`, found enum `std::result::Result` + | ^^^^^ expected enum `Option`, found enum `Result` | = note: expected enum `Option<Box<{integer}>>` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-12552.stderr b/src/test/ui/issues/issue-12552.stderr index 1594c9f503a..3d8852ca748 100644 --- a/src/test/ui/issues/issue-12552.stderr +++ b/src/test/ui/issues/issue-12552.stderr @@ -2,23 +2,23 @@ error[E0308]: mismatched types --> $DIR/issue-12552.rs:6:5 | LL | match t { - | - this expression has type `std::result::Result<_, {integer}>` + | - this expression has type `Result<_, {integer}>` LL | Some(k) => match k { - | ^^^^^^^ expected enum `std::result::Result`, found enum `Option` + | ^^^^^^^ expected enum `Result`, found enum `Option` | - = note: expected enum `std::result::Result<_, {integer}>` + = note: expected enum `Result<_, {integer}>` found enum `Option<_>` error[E0308]: mismatched types --> $DIR/issue-12552.rs:9:5 | LL | match t { - | - this expression has type `std::result::Result<_, {integer}>` + | - this expression has type `Result<_, {integer}>` ... LL | None => () - | ^^^^ expected enum `std::result::Result`, found enum `Option` + | ^^^^ expected enum `Result`, found enum `Option` | - = note: expected enum `std::result::Result<_, {integer}>` + = note: expected enum `Result<_, {integer}>` found enum `Option<_>` error: aborting due to 2 previous errors diff --git a/src/test/ui/issues/issue-13466.rs b/src/test/ui/issues/issue-13466.rs index 8048dae1239..a420c7704af 100644 --- a/src/test/ui/issues/issue-13466.rs +++ b/src/test/ui/issues/issue-13466.rs @@ -8,13 +8,13 @@ pub fn main() { Ok(u) => u, //~^ ERROR mismatched types //~| expected enum `Option<{integer}>` - //~| found enum `std::result::Result<_, _>` - //~| expected enum `Option`, found enum `std::result::Result` + //~| found enum `Result<_, _>` + //~| expected enum `Option`, found enum `Result` Err(e) => panic!(e) //~^ ERROR mismatched types //~| expected enum `Option<{integer}>` - //~| found enum `std::result::Result<_, _>` - //~| expected enum `Option`, found enum `std::result::Result` + //~| found enum `Result<_, _>` + //~| expected enum `Option`, found enum `Result` }; } diff --git a/src/test/ui/issues/issue-13466.stderr b/src/test/ui/issues/issue-13466.stderr index 792cc398bb8..c78466f4e8c 100644 --- a/src/test/ui/issues/issue-13466.stderr +++ b/src/test/ui/issues/issue-13466.stderr @@ -4,10 +4,10 @@ error[E0308]: mismatched types LL | let _x: usize = match Some(1) { | ------- this expression has type `Option<{integer}>` LL | Ok(u) => u, - | ^^^^^ expected enum `Option`, found enum `std::result::Result` + | ^^^^^ expected enum `Option`, found enum `Result` | = note: expected enum `Option<{integer}>` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error[E0308]: mismatched types --> $DIR/issue-13466.rs:14:9 @@ -16,10 +16,10 @@ LL | let _x: usize = match Some(1) { | ------- this expression has type `Option<{integer}>` ... LL | Err(e) => panic!(e) - | ^^^^^^ expected enum `Option`, found enum `std::result::Result` + | ^^^^^^ expected enum `Option`, found enum `Result` | = note: expected enum `Option<{integer}>` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error: aborting due to 2 previous errors diff --git a/src/test/ui/issues/issue-18919.stderr b/src/test/ui/issues/issue-18919.stderr index ece714c949c..d4b93eb074c 100644 --- a/src/test/ui/issues/issue-18919.stderr +++ b/src/test/ui/issues/issue-18919.stderr @@ -14,7 +14,7 @@ help: you could relax the implicit `Sized` bound on `T` if it were used through LL | enum Option<T> { | ^ this could be changed to `T: ?Sized`... LL | Some(T), - | - ...if indirection was used here: `Box<T>` + | - ...if indirection were used here: `Box<T>` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-21332.rs b/src/test/ui/issues/issue-21332.rs index 1b13f000b8c..6547f3a9b19 100644 --- a/src/test/ui/issues/issue-21332.rs +++ b/src/test/ui/issues/issue-21332.rs @@ -4,7 +4,7 @@ impl Iterator for S { type Item = i32; fn next(&mut self) -> Result<i32, i32> { Ok(7) } //~^ ERROR method `next` has an incompatible type for trait - //~| expected enum `Option`, found enum `std::result::Result` + //~| expected enum `Option`, found enum `Result` } fn main() {} diff --git a/src/test/ui/issues/issue-21332.stderr b/src/test/ui/issues/issue-21332.stderr index 1d6ddd2660e..35863fbebe3 100644 --- a/src/test/ui/issues/issue-21332.stderr +++ b/src/test/ui/issues/issue-21332.stderr @@ -2,10 +2,10 @@ error[E0053]: method `next` has an incompatible type for trait --> $DIR/issue-21332.rs:5:5 | LL | fn next(&mut self) -> Result<i32, i32> { Ok(7) } - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Option`, found enum `std::result::Result` + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Option`, found enum `Result` | = note: expected fn pointer `fn(&mut S) -> Option<i32>` - found fn pointer `fn(&mut S) -> std::result::Result<i32, i32>` + found fn pointer `fn(&mut S) -> Result<i32, i32>` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-23281.stderr b/src/test/ui/issues/issue-23281.stderr index d8046497b98..a3d25832925 100644 --- a/src/test/ui/issues/issue-23281.stderr +++ b/src/test/ui/issues/issue-23281.stderr @@ -14,7 +14,7 @@ help: you could relax the implicit `Sized` bound on `T` if it were used through LL | struct Vec<T> { | ^ this could be changed to `T: ?Sized`... LL | t: T, - | - ...if indirection was used here: `Box<T>` + | - ...if indirection were used here: `Box<T>` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-29821.rs b/src/test/ui/issues/issue-29821.rs new file mode 100644 index 00000000000..54be3afb59d --- /dev/null +++ b/src/test/ui/issues/issue-29821.rs @@ -0,0 +1,19 @@ +// build-pass + +pub trait Foo { + type FooAssoc; +} + +pub struct Bar<F: Foo> { + id: F::FooAssoc +} + +pub struct Baz; + +impl Foo for Baz { + type FooAssoc = usize; +} + +static mut MY_FOO: Bar<Baz> = Bar { id: 0 }; + +fn main() {} diff --git a/src/test/ui/issues/issue-3680.rs b/src/test/ui/issues/issue-3680.rs index 8912e7a18ac..37c9000c043 100644 --- a/src/test/ui/issues/issue-3680.rs +++ b/src/test/ui/issues/issue-3680.rs @@ -3,7 +3,7 @@ fn main() { Err(_) => () //~^ ERROR mismatched types //~| expected enum `Option<_>` - //~| found enum `std::result::Result<_, _>` - //~| expected enum `Option`, found enum `std::result::Result` + //~| found enum `Result<_, _>` + //~| expected enum `Option`, found enum `Result` } } diff --git a/src/test/ui/issues/issue-3680.stderr b/src/test/ui/issues/issue-3680.stderr index 479942b8e2c..e8fafa76b91 100644 --- a/src/test/ui/issues/issue-3680.stderr +++ b/src/test/ui/issues/issue-3680.stderr @@ -4,10 +4,10 @@ error[E0308]: mismatched types LL | match None { | ---- this expression has type `Option<_>` LL | Err(_) => () - | ^^^^^^ expected enum `Option`, found enum `std::result::Result` + | ^^^^^^ expected enum `Option`, found enum `Result` | = note: expected enum `Option<_>` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-4736.stderr b/src/test/ui/issues/issue-4736.stderr index 257ec914a61..9be4eb1c7fd 100644 --- a/src/test/ui/issues/issue-4736.stderr +++ b/src/test/ui/issues/issue-4736.stderr @@ -7,7 +7,7 @@ LL | struct NonCopyable(()); LL | let z = NonCopyable{ p: () }; | ----------- ^ field does not exist | | - | `NonCopyable` is a tuple struct, use the appropriate syntax: `NonCopyable(/* fields */)` + | help: `NonCopyable` is a tuple struct, use the appropriate syntax: `NonCopyable(/* fields */)` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-49934-errors.rs b/src/test/ui/issues/issue-49934-errors.rs index bf95f8fa7e1..dd14bac5e3a 100644 --- a/src/test/ui/issues/issue-49934-errors.rs +++ b/src/test/ui/issues/issue-49934-errors.rs @@ -1,11 +1,8 @@ -fn foo<#[derive(Debug)] T>() { -//~^ ERROR `derive` may only be applied to structs, enums and unions +fn foo<#[derive(Debug)] T>() { //~ ERROR expected non-macro attribute, found attribute macro match 0 { - #[derive(Debug)] - //~^ ERROR `derive` may only be applied to structs, enums and unions + #[derive(Debug)] //~ ERROR expected non-macro attribute, found attribute macro _ => (), } } -fn main() { -} +fn main() {} diff --git a/src/test/ui/issues/issue-49934-errors.stderr b/src/test/ui/issues/issue-49934-errors.stderr index 71cd2d30342..8c4c54170a1 100644 --- a/src/test/ui/issues/issue-49934-errors.stderr +++ b/src/test/ui/issues/issue-49934-errors.stderr @@ -1,15 +1,14 @@ -error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-49934-errors.rs:1:8 +error: expected non-macro attribute, found attribute macro `derive` + --> $DIR/issue-49934-errors.rs:1:10 | LL | fn foo<#[derive(Debug)] T>() { - | ^^^^^^^^^^^^^^^^ + | ^^^^^^ not a non-macro attribute -error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-49934-errors.rs:4:9 +error: expected non-macro attribute, found attribute macro `derive` + --> $DIR/issue-49934-errors.rs:3:11 | LL | #[derive(Debug)] - | ^^^^^^^^^^^^^^^^ + | ^^^^^^ not a non-macro attribute error: aborting due to 2 previous errors -For more information about this error, try `rustc --explain E0774`. diff --git a/src/test/ui/issues/issue-49934.rs b/src/test/ui/issues/issue-49934.rs index 5b253750db0..ec73e670634 100644 --- a/src/test/ui/issues/issue-49934.rs +++ b/src/test/ui/issues/issue-49934.rs @@ -1,7 +1,4 @@ -// check-pass - #![feature(stmt_expr_attributes)] -#![warn(unused_attributes)] //~ NOTE the lint level is defined here fn main() { // fold_stmt (Item) @@ -10,26 +7,24 @@ fn main() { struct Foo; // fold_stmt (Mac) - #[derive(Debug)] - //~^ WARN `#[derive]` does nothing on macro invocations - //~| NOTE this may become a hard error in a future release + #[derive(Debug)] //~ ERROR `derive` may only be applied to structs, enums and unions println!("Hello, world!"); // fold_stmt (Semi) - #[derive(Debug)] //~ WARN unused attribute + #[derive(Debug)] //~ ERROR `derive` may only be applied to structs, enums and unions "Hello, world!"; // fold_stmt (Local) - #[derive(Debug)] //~ WARN unused attribute + #[derive(Debug)] //~ ERROR `derive` may only be applied to structs, enums and unions let _ = "Hello, world!"; // visit_expr let _ = #[derive(Debug)] "Hello, world!"; - //~^ WARN unused attribute + //~^ ERROR `derive` may only be applied to structs, enums and unions let _ = [ // filter_map_expr - #[derive(Debug)] //~ WARN unused attribute - "Hello, world!" + #[derive(Debug)] //~ ERROR `derive` may only be applied to structs, enums and unions + "Hello, world!", ]; } diff --git a/src/test/ui/issues/issue-49934.stderr b/src/test/ui/issues/issue-49934.stderr index 8a5596521ec..7746ad287ab 100644 --- a/src/test/ui/issues/issue-49934.stderr +++ b/src/test/ui/issues/issue-49934.stderr @@ -1,40 +1,33 @@ -warning: `#[derive]` does nothing on macro invocations - --> $DIR/issue-49934.rs:13:5 +error[E0774]: `derive` may only be applied to structs, enums and unions + --> $DIR/issue-49934.rs:10:5 | LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ - | - = note: this may become a hard error in a future release -warning: unused attribute - --> $DIR/issue-49934.rs:19:5 +error[E0774]: `derive` may only be applied to structs, enums and unions + --> $DIR/issue-49934.rs:14:5 | LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ - | -note: the lint level is defined here - --> $DIR/issue-49934.rs:4:9 - | -LL | #![warn(unused_attributes)] - | ^^^^^^^^^^^^^^^^^ -warning: unused attribute - --> $DIR/issue-49934.rs:23:5 +error[E0774]: `derive` may only be applied to structs, enums and unions + --> $DIR/issue-49934.rs:18:5 | LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ -warning: unused attribute - --> $DIR/issue-49934.rs:27:13 +error[E0774]: `derive` may only be applied to structs, enums and unions + --> $DIR/issue-49934.rs:22:13 | LL | let _ = #[derive(Debug)] "Hello, world!"; | ^^^^^^^^^^^^^^^^ -warning: unused attribute - --> $DIR/issue-49934.rs:32:9 +error[E0774]: `derive` may only be applied to structs, enums and unions + --> $DIR/issue-49934.rs:27:9 | LL | #[derive(Debug)] | ^^^^^^^^^^^^^^^^ -warning: 5 warnings emitted +error: aborting due to 5 previous errors +For more information about this error, try `rustc --explain E0774`. diff --git a/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr b/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr index e41c04ee89e..9711e27d8a8 100644 --- a/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr +++ b/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr @@ -1,4 +1,4 @@ -error[E0599]: the method `as_deref` exists for enum `std::result::Result<{integer}, _>`, but its trait bounds were not satisfied +error[E0599]: the method `as_deref` exists for enum `Result<{integer}, _>`, but its trait bounds were not satisfied --> $DIR/result-as_deref.rs:2:27 | LL | let _result = &Ok(42).as_deref(); diff --git a/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr b/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr index 372d056fc19..ee7ea1e6a02 100644 --- a/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr +++ b/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr @@ -1,8 +1,8 @@ -error[E0599]: the method `as_deref_mut` exists for enum `std::result::Result<{integer}, _>`, but its trait bounds were not satisfied +error[E0599]: the method `as_deref_mut` exists for enum `Result<{integer}, _>`, but its trait bounds were not satisfied --> $DIR/result-as_deref_mut.rs:2:31 | LL | let _result = &mut Ok(42).as_deref_mut(); - | ^^^^^^^^^^^^ method cannot be called on `std::result::Result<{integer}, _>` due to unsatisfied trait bounds + | ^^^^^^^^^^^^ method cannot be called on `Result<{integer}, _>` due to unsatisfied trait bounds | = note: the following trait bounds were not satisfied: `{integer}: DerefMut` diff --git a/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr b/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr index 9ca983df30a..554ac7e7c75 100644 --- a/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr +++ b/src/test/ui/issues/issue-51632-try-desugar-incompatible-types.stderr @@ -2,9 +2,9 @@ error[E0308]: try expression alternatives have incompatible types --> $DIR/issue-51632-try-desugar-incompatible-types.rs:8:5 | LL | missing_discourses()? - | ^^^^^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found `isize` + | ^^^^^^^^^^^^^^^^^^^^^ expected enum `Result`, found `isize` | - = note: expected enum `std::result::Result<isize, ()>` + = note: expected enum `Result<isize, ()>` found type `isize` help: try removing this `?` | diff --git a/src/test/ui/issues/issue-6458-4.stderr b/src/test/ui/issues/issue-6458-4.stderr index 00ebff9007d..0cf82d37d5d 100644 --- a/src/test/ui/issues/issue-6458-4.stderr +++ b/src/test/ui/issues/issue-6458-4.stderr @@ -2,13 +2,13 @@ error[E0308]: mismatched types --> $DIR/issue-6458-4.rs:1:20 | LL | fn foo(b: bool) -> Result<bool,String> { - | --- ^^^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found `()` + | --- ^^^^^^^^^^^^^^^^^^^ expected enum `Result`, found `()` | | | implicitly returns `()` as its body has no tail or `return` expression LL | Err("bar".to_string()); | - help: consider removing this semicolon | - = note: expected enum `std::result::Result<bool, String>` + = note: expected enum `Result<bool, String>` found unit type `()` error: aborting due to previous error diff --git a/src/test/ui/issues/issue-80607.stderr b/src/test/ui/issues/issue-80607.stderr index 5375478942b..22a660b4167 100644 --- a/src/test/ui/issues/issue-80607.stderr +++ b/src/test/ui/issues/issue-80607.stderr @@ -7,7 +7,7 @@ LL | V1(i32), LL | Enum::V1 { x } | -------- ^ field does not exist | | - | `Enum::V1` is a tuple variant, use the appropriate syntax: `Enum::V1(/* fields */)` + | help: `Enum::V1` is a tuple variant, use the appropriate syntax: `Enum::V1(/* fields */)` error: aborting due to previous error diff --git a/src/test/ui/lifetimes/lifetime-elision-return-type-trait.stderr b/src/test/ui/lifetimes/lifetime-elision-return-type-trait.stderr index c3d597bec2e..ef1127c59ac 100644 --- a/src/test/ui/lifetimes/lifetime-elision-return-type-trait.stderr +++ b/src/test/ui/lifetimes/lifetime-elision-return-type-trait.stderr @@ -1,8 +1,8 @@ -error[E0277]: the trait bound `std::result::Result<(), _>: Future` is not satisfied +error[E0277]: the trait bound `Result<(), _>: Future` is not satisfied --> $DIR/lifetime-elision-return-type-trait.rs:8:13 | LL | fn foo() -> impl Future<Item=(), Error=Box<dyn Error>> { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Future` is not implemented for `std::result::Result<(), _>` + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Future` is not implemented for `Result<(), _>` error: aborting due to previous error diff --git a/src/test/ui/huge-array-simple-32.rs b/src/test/ui/limits/huge-array-simple-32.rs index 2290e3d5e76..2290e3d5e76 100644 --- a/src/test/ui/huge-array-simple-32.rs +++ b/src/test/ui/limits/huge-array-simple-32.rs diff --git a/src/test/ui/huge-array-simple-32.stderr b/src/test/ui/limits/huge-array-simple-32.stderr index 31e120df626..31e120df626 100644 --- a/src/test/ui/huge-array-simple-32.stderr +++ b/src/test/ui/limits/huge-array-simple-32.stderr diff --git a/src/test/ui/huge-array-simple-64.rs b/src/test/ui/limits/huge-array-simple-64.rs index 02c961fc5fa..02c961fc5fa 100644 --- a/src/test/ui/huge-array-simple-64.rs +++ b/src/test/ui/limits/huge-array-simple-64.rs diff --git a/src/test/ui/huge-array-simple-64.stderr b/src/test/ui/limits/huge-array-simple-64.stderr index c5d3fe85d0d..c5d3fe85d0d 100644 --- a/src/test/ui/huge-array-simple-64.stderr +++ b/src/test/ui/limits/huge-array-simple-64.stderr diff --git a/src/test/ui/huge-array.rs b/src/test/ui/limits/huge-array.rs index 3070801f865..3070801f865 100644 --- a/src/test/ui/huge-array.rs +++ b/src/test/ui/limits/huge-array.rs diff --git a/src/test/ui/huge-array.stderr b/src/test/ui/limits/huge-array.stderr index 817458b73e4..817458b73e4 100644 --- a/src/test/ui/huge-array.stderr +++ b/src/test/ui/limits/huge-array.stderr diff --git a/src/test/ui/huge-enum.rs b/src/test/ui/limits/huge-enum.rs index 39ea6e11b1f..39ea6e11b1f 100644 --- a/src/test/ui/huge-enum.rs +++ b/src/test/ui/limits/huge-enum.rs diff --git a/src/test/ui/huge-enum.stderr b/src/test/ui/limits/huge-enum.stderr index a1456e1a8ab..a1456e1a8ab 100644 --- a/src/test/ui/huge-enum.stderr +++ b/src/test/ui/limits/huge-enum.stderr diff --git a/src/test/ui/huge-struct.rs b/src/test/ui/limits/huge-struct.rs index 02f38d860b4..02f38d860b4 100644 --- a/src/test/ui/huge-struct.rs +++ b/src/test/ui/limits/huge-struct.rs diff --git a/src/test/ui/huge-struct.stderr b/src/test/ui/limits/huge-struct.stderr index f0ee88e5955..f0ee88e5955 100644 --- a/src/test/ui/huge-struct.stderr +++ b/src/test/ui/limits/huge-struct.stderr diff --git a/src/test/ui/issues/issue-15919-32.rs b/src/test/ui/limits/issue-15919-32.rs index 3c93f14ccc7..3c93f14ccc7 100644 --- a/src/test/ui/issues/issue-15919-32.rs +++ b/src/test/ui/limits/issue-15919-32.rs diff --git a/src/test/ui/issues/issue-15919-32.stderr b/src/test/ui/limits/issue-15919-32.stderr index 133637f9a05..133637f9a05 100644 --- a/src/test/ui/issues/issue-15919-32.stderr +++ b/src/test/ui/limits/issue-15919-32.stderr diff --git a/src/test/ui/issues/issue-15919-64.rs b/src/test/ui/limits/issue-15919-64.rs index 3ecbd34eaaa..3ecbd34eaaa 100644 --- a/src/test/ui/issues/issue-15919-64.rs +++ b/src/test/ui/limits/issue-15919-64.rs diff --git a/src/test/ui/issues/issue-15919-64.stderr b/src/test/ui/limits/issue-15919-64.stderr index 193b823035c..193b823035c 100644 --- a/src/test/ui/issues/issue-15919-64.stderr +++ b/src/test/ui/limits/issue-15919-64.stderr diff --git a/src/test/ui/issues/issue-17913.rs b/src/test/ui/limits/issue-17913.rs index ca13b9bd6ae..ca13b9bd6ae 100644 --- a/src/test/ui/issues/issue-17913.rs +++ b/src/test/ui/limits/issue-17913.rs diff --git a/src/test/ui/issues/issue-17913.stderr b/src/test/ui/limits/issue-17913.stderr index 9a6431d4470..9a6431d4470 100644 --- a/src/test/ui/issues/issue-17913.stderr +++ b/src/test/ui/limits/issue-17913.stderr diff --git a/src/test/ui/consts/issue-55878.rs b/src/test/ui/limits/issue-55878.rs index c1c54646db8..c1c54646db8 100644 --- a/src/test/ui/consts/issue-55878.rs +++ b/src/test/ui/limits/issue-55878.rs diff --git a/src/test/ui/consts/issue-55878.stderr b/src/test/ui/limits/issue-55878.stderr index a0e8fc70b6a..a0e8fc70b6a 100644 --- a/src/test/ui/consts/issue-55878.stderr +++ b/src/test/ui/limits/issue-55878.stderr diff --git a/src/test/ui/consts/issue-56762.rs b/src/test/ui/limits/issue-56762.rs index fb0a270f18b..fb0a270f18b 100644 --- a/src/test/ui/consts/issue-56762.rs +++ b/src/test/ui/limits/issue-56762.rs diff --git a/src/test/ui/consts/issue-56762.stderr b/src/test/ui/limits/issue-56762.stderr index f26ef280b20..f26ef280b20 100644 --- a/src/test/ui/consts/issue-56762.stderr +++ b/src/test/ui/limits/issue-56762.stderr diff --git a/src/test/ui/lint/issue-69485-var-size-diffs-too-large.rs b/src/test/ui/limits/issue-69485-var-size-diffs-too-large.rs index 2560ffe168b..2560ffe168b 100644 --- a/src/test/ui/lint/issue-69485-var-size-diffs-too-large.rs +++ b/src/test/ui/limits/issue-69485-var-size-diffs-too-large.rs diff --git a/src/test/ui/lint/issue-69485-var-size-diffs-too-large.stderr b/src/test/ui/limits/issue-69485-var-size-diffs-too-large.stderr index c229458da47..c229458da47 100644 --- a/src/test/ui/lint/issue-69485-var-size-diffs-too-large.stderr +++ b/src/test/ui/limits/issue-69485-var-size-diffs-too-large.stderr diff --git a/src/test/ui/limits/issue-75158-64.rs b/src/test/ui/limits/issue-75158-64.rs new file mode 100644 index 00000000000..06c209c078f --- /dev/null +++ b/src/test/ui/limits/issue-75158-64.rs @@ -0,0 +1,16 @@ +//~ ERROR + +// build-fail +// ignore-32bit + +struct S<T> { + x: [T; !0], +} + +pub fn f() -> usize { + std::mem::size_of::<S<u8>>() +} + +fn main() { + let x = f(); +} diff --git a/src/test/ui/limits/issue-75158-64.stderr b/src/test/ui/limits/issue-75158-64.stderr new file mode 100644 index 00000000000..dc11d056154 --- /dev/null +++ b/src/test/ui/limits/issue-75158-64.stderr @@ -0,0 +1,4 @@ +error: values of the type `[u8; 18446744073709551615]` are too big for the current architecture + +error: aborting due to previous error + diff --git a/src/test/ui/lint/lint-ctypes-enum.stderr b/src/test/ui/lint/lint-ctypes-enum.stderr index 8917d309e60..f3991ab4177 100644 --- a/src/test/ui/lint/lint-ctypes-enum.stderr +++ b/src/test/ui/lint/lint-ctypes-enum.stderr @@ -97,7 +97,7 @@ LL | fn repr_rust(x: Option<Rust<num::NonZeroU8>>); = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum = note: enum has no representation hint -error: `extern` block uses type `std::result::Result<(), NonZeroI32>`, which is not FFI-safe +error: `extern` block uses type `Result<(), NonZeroI32>`, which is not FFI-safe --> $DIR/lint-ctypes-enum.rs:90:20 | LL | fn no_result(x: Result<(), num::NonZeroI32>); diff --git a/src/test/ui/lint/must_use-tuple.rs b/src/test/ui/lint/must_use-tuple.rs index f6b579a7f35..0f0aa20253c 100644 --- a/src/test/ui/lint/must_use-tuple.rs +++ b/src/test/ui/lint/must_use-tuple.rs @@ -5,13 +5,13 @@ fn foo() -> (Result<(), ()>, ()) { } fn main() { - (Ok::<(), ()>(()),); //~ ERROR unused `std::result::Result` + (Ok::<(), ()>(()),); //~ ERROR unused `Result` (Ok::<(), ()>(()), 0, Ok::<(), ()>(()), 5); - //~^ ERROR unused `std::result::Result` - //~^^ ERROR unused `std::result::Result` + //~^ ERROR unused `Result` + //~^^ ERROR unused `Result` - foo(); //~ ERROR unused `std::result::Result` + foo(); //~ ERROR unused `Result` - ((Err::<(), ()>(()), ()), ()); //~ ERROR unused `std::result::Result` + ((Err::<(), ()>(()), ()), ()); //~ ERROR unused `Result` } diff --git a/src/test/ui/lint/must_use-tuple.stderr b/src/test/ui/lint/must_use-tuple.stderr index de3c6f46c68..0532d89e039 100644 --- a/src/test/ui/lint/must_use-tuple.stderr +++ b/src/test/ui/lint/must_use-tuple.stderr @@ -1,4 +1,4 @@ -error: unused `std::result::Result` in tuple element 0 that must be used +error: unused `Result` in tuple element 0 that must be used --> $DIR/must_use-tuple.rs:8:6 | LL | (Ok::<(), ()>(()),); @@ -11,7 +11,7 @@ LL | #![deny(unused_must_use)] | ^^^^^^^^^^^^^^^ = note: this `Result` may be an `Err` variant, which should be handled -error: unused `std::result::Result` in tuple element 0 that must be used +error: unused `Result` in tuple element 0 that must be used --> $DIR/must_use-tuple.rs:10:6 | LL | (Ok::<(), ()>(()), 0, Ok::<(), ()>(()), 5); @@ -19,7 +19,7 @@ LL | (Ok::<(), ()>(()), 0, Ok::<(), ()>(()), 5); | = note: this `Result` may be an `Err` variant, which should be handled -error: unused `std::result::Result` in tuple element 2 that must be used +error: unused `Result` in tuple element 2 that must be used --> $DIR/must_use-tuple.rs:10:27 | LL | (Ok::<(), ()>(()), 0, Ok::<(), ()>(()), 5); @@ -27,7 +27,7 @@ LL | (Ok::<(), ()>(()), 0, Ok::<(), ()>(()), 5); | = note: this `Result` may be an `Err` variant, which should be handled -error: unused `std::result::Result` in tuple element 0 that must be used +error: unused `Result` in tuple element 0 that must be used --> $DIR/must_use-tuple.rs:14:5 | LL | foo(); @@ -35,7 +35,7 @@ LL | foo(); | = note: this `Result` may be an `Err` variant, which should be handled -error: unused `std::result::Result` in tuple element 0 that must be used +error: unused `Result` in tuple element 0 that must be used --> $DIR/must_use-tuple.rs:16:6 | LL | ((Err::<(), ()>(()), ()), ()); diff --git a/src/test/ui/macros/builtin-std-paths-fail.stderr b/src/test/ui/macros/builtin-std-paths-fail.stderr index 9831e46ec30..4f1a76b0d6e 100644 --- a/src/test/ui/macros/builtin-std-paths-fail.stderr +++ b/src/test/ui/macros/builtin-std-paths-fail.stderr @@ -1,3 +1,15 @@ +error[E0433]: failed to resolve: could not find `RustcDecodable` in `core` + --> $DIR/builtin-std-paths-fail.rs:2:11 + | +LL | core::RustcDecodable, + | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `core` + +error[E0433]: failed to resolve: could not find `RustcDecodable` in `core` + --> $DIR/builtin-std-paths-fail.rs:4:11 + | +LL | core::RustcDecodable, + | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `core` + error[E0433]: failed to resolve: could not find `bench` in `core` --> $DIR/builtin-std-paths-fail.rs:7:9 | @@ -23,28 +35,28 @@ LL | #[core::test] | ^^^^ could not find `test` in `core` error[E0433]: failed to resolve: could not find `RustcDecodable` in `core` - --> $DIR/builtin-std-paths-fail.rs:2:11 + --> $DIR/builtin-std-paths-fail.rs:4:11 | LL | core::RustcDecodable, | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `core` error[E0433]: failed to resolve: could not find `RustcDecodable` in `core` - --> $DIR/builtin-std-paths-fail.rs:4:11 + --> $DIR/builtin-std-paths-fail.rs:2:11 | LL | core::RustcDecodable, | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `core` -error[E0433]: failed to resolve: could not find `RustcDecodable` in `core` - --> $DIR/builtin-std-paths-fail.rs:4:11 +error[E0433]: failed to resolve: could not find `RustcDecodable` in `std` + --> $DIR/builtin-std-paths-fail.rs:14:10 | -LL | core::RustcDecodable, - | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `core` +LL | std::RustcDecodable, + | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `std` -error[E0433]: failed to resolve: could not find `RustcDecodable` in `core` - --> $DIR/builtin-std-paths-fail.rs:2:11 +error[E0433]: failed to resolve: could not find `RustcDecodable` in `std` + --> $DIR/builtin-std-paths-fail.rs:16:10 | -LL | core::RustcDecodable, - | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `core` +LL | std::RustcDecodable, + | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `std` error[E0433]: failed to resolve: could not find `bench` in `std` --> $DIR/builtin-std-paths-fail.rs:19:8 @@ -71,18 +83,6 @@ LL | #[std::test] | ^^^^ could not find `test` in `std` error[E0433]: failed to resolve: could not find `RustcDecodable` in `std` - --> $DIR/builtin-std-paths-fail.rs:14:10 - | -LL | std::RustcDecodable, - | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `std` - -error[E0433]: failed to resolve: could not find `RustcDecodable` in `std` - --> $DIR/builtin-std-paths-fail.rs:16:10 - | -LL | std::RustcDecodable, - | ^^^^^^^^^^^^^^ could not find `RustcDecodable` in `std` - -error[E0433]: failed to resolve: could not find `RustcDecodable` in `std` --> $DIR/builtin-std-paths-fail.rs:16:10 | LL | std::RustcDecodable, diff --git a/src/test/ui/macros/must-use-in-macro-55516.stderr b/src/test/ui/macros/must-use-in-macro-55516.stderr index a694c887085..b4072a1ad7e 100644 --- a/src/test/ui/macros/must-use-in-macro-55516.stderr +++ b/src/test/ui/macros/must-use-in-macro-55516.stderr @@ -1,4 +1,4 @@ -warning: unused `std::result::Result` that must be used +warning: unused `Result` that must be used --> $DIR/must-use-in-macro-55516.rs:9:5 | LL | write!(&mut example, "{}", 42); diff --git a/src/test/ui/malformed/issue-69341-malformed-derive-inert.rs b/src/test/ui/malformed/issue-69341-malformed-derive-inert.rs index 1fd7cddc7c9..fc4c3f4e64b 100644 --- a/src/test/ui/malformed/issue-69341-malformed-derive-inert.rs +++ b/src/test/ui/malformed/issue-69341-malformed-derive-inert.rs @@ -1,9 +1,6 @@ fn main() {} struct CLI { - #[derive(parse())] - //~^ ERROR traits in `#[derive(...)]` don't accept arguments - //~| ERROR cannot find derive macro `parse` in this scope + #[derive(parse())] //~ ERROR expected non-macro attribute, found attribute macro path: (), - //~^ ERROR `derive` may only be applied to structs, enums and unions } diff --git a/src/test/ui/malformed/issue-69341-malformed-derive-inert.stderr b/src/test/ui/malformed/issue-69341-malformed-derive-inert.stderr index db40ce07530..04f7ebe019e 100644 --- a/src/test/ui/malformed/issue-69341-malformed-derive-inert.stderr +++ b/src/test/ui/malformed/issue-69341-malformed-derive-inert.stderr @@ -1,21 +1,8 @@ -error: traits in `#[derive(...)]` don't accept arguments - --> $DIR/issue-69341-malformed-derive-inert.rs:4:19 +error: expected non-macro attribute, found attribute macro `derive` + --> $DIR/issue-69341-malformed-derive-inert.rs:4:7 | LL | #[derive(parse())] - | ^^ help: remove the arguments + | ^^^^^^ not a non-macro attribute -error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-69341-malformed-derive-inert.rs:7:5 - | -LL | path: (), - | ^^^^^^^^ - -error: cannot find derive macro `parse` in this scope - --> $DIR/issue-69341-malformed-derive-inert.rs:4:14 - | -LL | #[derive(parse())] - | ^^^^^ - -error: aborting due to 3 previous errors +error: aborting due to previous error -For more information about this error, try `rustc --explain E0774`. diff --git a/src/test/ui/malformed/malformed-derive-entry.stderr b/src/test/ui/malformed/malformed-derive-entry.stderr index 63be8f9ca14..365cc099e9d 100644 --- a/src/test/ui/malformed/malformed-derive-entry.stderr +++ b/src/test/ui/malformed/malformed-derive-entry.stderr @@ -14,7 +14,7 @@ error: malformed `derive` attribute input --> $DIR/malformed-derive-entry.rs:11:1 | LL | #[derive] - | ^^^^^^^^^ help: missing traits to be derived: `#[derive(Trait1, Trait2, ...)]` + | ^^^^^^^^^ help: must be of the form: `#[derive(Trait1, Trait2, ...)]` error[E0277]: the trait bound `Test1: Clone` is not satisfied --> $DIR/malformed-derive-entry.rs:1:10 diff --git a/src/test/ui/malformed/malformed-special-attrs.stderr b/src/test/ui/malformed/malformed-special-attrs.stderr index 6f535e03e6a..1764c3969cf 100644 --- a/src/test/ui/malformed/malformed-special-attrs.stderr +++ b/src/test/ui/malformed/malformed-special-attrs.stderr @@ -18,13 +18,13 @@ error: malformed `derive` attribute input --> $DIR/malformed-special-attrs.rs:7:1 | LL | #[derive] - | ^^^^^^^^^ help: missing traits to be derived: `#[derive(Trait1, Trait2, ...)]` + | ^^^^^^^^^ help: must be of the form: `#[derive(Trait1, Trait2, ...)]` error: malformed `derive` attribute input --> $DIR/malformed-special-attrs.rs:10:1 | LL | #[derive = ""] - | ^^^^^^^^^^^^^^ help: missing traits to be derived: `#[derive(Trait1, Trait2, ...)]` + | ^^^^^^^^^^^^^^ help: must be of the form: `#[derive(Trait1, Trait2, ...)]` error: aborting due to 4 previous errors diff --git a/src/test/ui/mir/issue-80949.rs b/src/test/ui/mir/issue-80949.rs new file mode 100644 index 00000000000..7e34a4f5c27 --- /dev/null +++ b/src/test/ui/mir/issue-80949.rs @@ -0,0 +1,34 @@ +// build-pass + +trait Trait { type Item; } + +impl<'a, X> Trait for &'a Vec<X> { + type Item = &'a X; +} + +impl<X> Trait for Box<dyn Trait<Item = X>> { + type Item = X; +} + +fn make_dyn_trait(_: &()) -> Box<dyn Trait<Item = &()>> { + todo!() +} + +fn diff<'a, M, N, S>(_: N, _: S) +where + M: 'a, + N: Trait<Item = &'a M>, + S: Trait<Item = &'a M>, +{ + todo!() +} + +fn may_panic<X>(_: X) { } + +fn main() { + let dyn_trait = make_dyn_trait(&()); + let storage = vec![()]; + let _x = may_panic(()); + let storage_ref = &storage; + diff(dyn_trait, storage_ref); +} diff --git a/src/test/ui/mismatched_types/abridged.stderr b/src/test/ui/mismatched_types/abridged.stderr index b7564686cd5..61994e5bfee 100644 --- a/src/test/ui/mismatched_types/abridged.stderr +++ b/src/test/ui/mismatched_types/abridged.stderr @@ -15,10 +15,10 @@ error[E0308]: mismatched types LL | fn a2() -> Foo { | --- expected `Foo` because of return type LL | Ok(Foo { bar: 1}) - | ^^^^^^^^^^^^^^^^^ expected struct `Foo`, found enum `std::result::Result` + | ^^^^^^^^^^^^^^^^^ expected struct `Foo`, found enum `Result` | = note: expected struct `Foo` - found enum `std::result::Result<Foo, _>` + found enum `Result<Foo, _>` error[E0308]: mismatched types --> $DIR/abridged.rs:24:5 @@ -38,14 +38,14 @@ error[E0308]: mismatched types --> $DIR/abridged.rs:28:5 | LL | fn c() -> Result<Foo, Bar> { - | ---------------- expected `std::result::Result<Foo, Bar>` because of return type + | ---------------- expected `Result<Foo, Bar>` because of return type LL | Foo { bar: 1 } | ^^^^^^^^^^^^^^ | | - | expected enum `std::result::Result`, found struct `Foo` + | expected enum `Result`, found struct `Foo` | help: try using a variant of the expected enum: `Ok(Foo { bar: 1 })` | - = note: expected enum `std::result::Result<Foo, Bar>` + = note: expected enum `Result<Foo, Bar>` found struct `Foo` error[E0308]: mismatched types diff --git a/src/test/ui/mismatched_types/binops.rs b/src/test/ui/mismatched_types/binops.rs index 4be7420e33c..f359451dfb8 100644 --- a/src/test/ui/mismatched_types/binops.rs +++ b/src/test/ui/mismatched_types/binops.rs @@ -4,5 +4,5 @@ fn main() { 3 * (); //~ ERROR cannot multiply `{integer}` by `()` 4 / ""; //~ ERROR cannot divide `{integer}` by `&str` 5 < String::new(); //~ ERROR can't compare `{integer}` with `String` - 6 == Ok(1); //~ ERROR can't compare `{integer}` with `std::result::Result<{integer}, _>` + 6 == Ok(1); //~ ERROR can't compare `{integer}` with `Result<{integer}, _>` } diff --git a/src/test/ui/mismatched_types/binops.stderr b/src/test/ui/mismatched_types/binops.stderr index f2bfb12ee9c..19e921dd04d 100644 --- a/src/test/ui/mismatched_types/binops.stderr +++ b/src/test/ui/mismatched_types/binops.stderr @@ -38,13 +38,13 @@ LL | 5 < String::new(); | = help: the trait `PartialOrd<String>` is not implemented for `{integer}` -error[E0277]: can't compare `{integer}` with `std::result::Result<{integer}, _>` +error[E0277]: can't compare `{integer}` with `Result<{integer}, _>` --> $DIR/binops.rs:7:7 | LL | 6 == Ok(1); - | ^^ no implementation for `{integer} == std::result::Result<{integer}, _>` + | ^^ no implementation for `{integer} == Result<{integer}, _>` | - = help: the trait `PartialEq<std::result::Result<{integer}, _>>` is not implemented for `{integer}` + = help: the trait `PartialEq<Result<{integer}, _>>` is not implemented for `{integer}` error: aborting due to 6 previous errors diff --git a/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr b/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr index 92a88cbdb34..1030061b2d1 100644 --- a/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr +++ b/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr @@ -1,11 +1,11 @@ -error[E0599]: the method `unwrap` exists for enum `std::result::Result<(), Foo>`, but its trait bounds were not satisfied +error[E0599]: the method `unwrap` exists for enum `Result<(), Foo>`, but its trait bounds were not satisfied --> $DIR/method-help-unsatisfied-bound.rs:5:7 | LL | struct Foo; | ----------- doesn't satisfy `Foo: Debug` ... LL | a.unwrap(); - | ^^^^^^ method cannot be called on `std::result::Result<(), Foo>` due to unsatisfied trait bounds + | ^^^^^^ method cannot be called on `Result<(), Foo>` due to unsatisfied trait bounds | = note: the following trait bounds were not satisfied: `Foo: Debug` diff --git a/src/test/ui/nll/issue-54556-niconii.stderr b/src/test/ui/nll/issue-54556-niconii.stderr index b4791fd22b4..1bfebd755b4 100644 --- a/src/test/ui/nll/issue-54556-niconii.stderr +++ b/src/test/ui/nll/issue-54556-niconii.stderr @@ -11,7 +11,7 @@ LL | } | - | | | `counter` dropped here while still borrowed - | ... and the borrow might be used here, when that temporary is dropped and runs the destructor for type `std::result::Result<MutexGuard<'_>, ()>` + | ... and the borrow might be used here, when that temporary is dropped and runs the destructor for type `Result<MutexGuard<'_>, ()>` | help: consider adding semicolon after the expression so its temporaries are dropped sooner, before the local variables declared by the block are dropped | diff --git a/src/test/ui/numeric/numeric-fields.stderr b/src/test/ui/numeric/numeric-fields.stderr index 5202393f559..13b6cfae4ec 100644 --- a/src/test/ui/numeric/numeric-fields.stderr +++ b/src/test/ui/numeric/numeric-fields.stderr @@ -7,7 +7,7 @@ LL | struct S(u8, u16); LL | let s = S{0b1: 10, 0: 11}; | - ^^^ field does not exist | | - | `S` is a tuple struct, use the appropriate syntax: `S(/* fields */)` + | help: `S` is a tuple struct, use the appropriate syntax: `S(/* fields */)` error[E0026]: struct `S` does not have a field named `0x1` --> $DIR/numeric-fields.rs:7:17 diff --git a/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.rs b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.rs index 184ffa85c40..bdb7a1ec92b 100644 --- a/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.rs +++ b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.rs @@ -48,6 +48,25 @@ fn main() { (1 | 1,) => {} //~ ERROR unreachable _ => {} } + match 0 { + (0 | 1) | 1 => {} //~ ERROR unreachable + _ => {} + } + match 0 { + // We get two errors because recursive or-pattern expansion means we don't notice the two + // errors span a whole pattern. This could be better but doesn't matter much + 0 | (0 | 0) => {} + //~^ ERROR unreachable + //~| ERROR unreachable + _ => {} + } + match None { + // There is only one error that correctly points to the whole subpattern + Some(0) | + Some( //~ ERROR unreachable + 0 | 0) => {} + _ => {} + } match [0; 2] { [0 | 0 //~ ERROR unreachable @@ -84,8 +103,8 @@ fn main() { } macro_rules! t_or_f { () => { - (true // FIXME: should be unreachable - | false) + (true //~ ERROR unreachable + | false) }; } match (true, None) { diff --git a/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr index 8b1003b5514..51991fc6039 100644 --- a/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr +++ b/src/test/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr @@ -77,58 +77,94 @@ LL | (1 | 1,) => {} | ^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:53:15 + --> $DIR/exhaustiveness-unreachable-pattern.rs:52:19 + | +LL | (0 | 1) | 1 => {} + | ^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:58:14 + | +LL | 0 | (0 | 0) => {} + | ^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:58:18 + | +LL | 0 | (0 | 0) => {} + | ^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:66:13 + | +LL | / Some( +LL | | 0 | 0) => {} + | |______________________^ + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:72:15 | LL | | 0 | ^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:55:15 + --> $DIR/exhaustiveness-unreachable-pattern.rs:74:15 | LL | | 0] => {} | ^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:63:10 + --> $DIR/exhaustiveness-unreachable-pattern.rs:82:10 | LL | [1 | ^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:75:10 + --> $DIR/exhaustiveness-unreachable-pattern.rs:94:10 | LL | [true | ^^^^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:82:36 + --> $DIR/exhaustiveness-unreachable-pattern.rs:101:36 | LL | (true | false, None | Some(true | ^^^^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:98:14 + --> $DIR/exhaustiveness-unreachable-pattern.rs:106:14 + | +LL | (true + | ^^^^ +... +LL | (true | false, None | Some(t_or_f!())) => {} + | --------- in this macro invocation + | + = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info) + +error: unreachable pattern + --> $DIR/exhaustiveness-unreachable-pattern.rs:117:14 | LL | Some(0 | ^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:117:19 + --> $DIR/exhaustiveness-unreachable-pattern.rs:136:19 | LL | | false) => {} | ^^^^^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:125:15 + --> $DIR/exhaustiveness-unreachable-pattern.rs:144:15 | LL | | true) => {} | ^^^^ error: unreachable pattern - --> $DIR/exhaustiveness-unreachable-pattern.rs:131:15 + --> $DIR/exhaustiveness-unreachable-pattern.rs:150:15 | LL | | true, | ^^^^ -error: aborting due to 21 previous errors +error: aborting due to 26 previous errors diff --git a/src/test/ui/or-patterns/inconsistent-modes.stderr b/src/test/ui/or-patterns/inconsistent-modes.stderr index c5dcef36e05..15790771043 100644 --- a/src/test/ui/or-patterns/inconsistent-modes.stderr +++ b/src/test/ui/or-patterns/inconsistent-modes.stderr @@ -65,7 +65,7 @@ error[E0308]: mismatched types --> $DIR/inconsistent-modes.rs:14:31 | LL | let Ok((ref a, b)) | Err((ref mut a, ref b)) = Ok((0, &0)); - | ----- ^^^^^^^^^ ----------- this expression has type `std::result::Result<({integer}, &{integer}), (_, _)>` + | ----- ^^^^^^^^^ ----------- this expression has type `Result<({integer}, &{integer}), (_, _)>` | | | | | types differ in mutability | first introduced with type `&{integer}` here diff --git a/src/test/ui/parser/ascii-only-character-escape.rs b/src/test/ui/parser/ascii-only-character-escape.rs index 20d3edf1251..725c8ad2351 100644 --- a/src/test/ui/parser/ascii-only-character-escape.rs +++ b/src/test/ui/parser/ascii-only-character-escape.rs @@ -1,6 +1,6 @@ fn main() { - let x = "\x80"; //~ ERROR may only be used - let y = "\xff"; //~ ERROR may only be used - let z = "\xe2"; //~ ERROR may only be used + let x = "\x80"; //~ ERROR out of range hex escape + let y = "\xff"; //~ ERROR out of range hex escape + let z = "\xe2"; //~ ERROR out of range hex escape let a = b"\x00e2"; // ok because byte literal } diff --git a/src/test/ui/parser/ascii-only-character-escape.stderr b/src/test/ui/parser/ascii-only-character-escape.stderr index cf51b00cdc3..b599b35f4b3 100644 --- a/src/test/ui/parser/ascii-only-character-escape.stderr +++ b/src/test/ui/parser/ascii-only-character-escape.stderr @@ -1,20 +1,20 @@ -error: this form of character escape may only be used with characters in the range [\x00-\x7f] +error: out of range hex escape --> $DIR/ascii-only-character-escape.rs:2:14 | LL | let x = "\x80"; - | ^^^^ + | ^^^^ must be a character in the range [\x00-\x7f] -error: this form of character escape may only be used with characters in the range [\x00-\x7f] +error: out of range hex escape --> $DIR/ascii-only-character-escape.rs:3:14 | LL | let y = "\xff"; - | ^^^^ + | ^^^^ must be a character in the range [\x00-\x7f] -error: this form of character escape may only be used with characters in the range [\x00-\x7f] +error: out of range hex escape --> $DIR/ascii-only-character-escape.rs:4:14 | LL | let z = "\xe2"; - | ^^^^ + | ^^^^ must be a character in the range [\x00-\x7f] error: aborting due to 3 previous errors diff --git a/src/test/ui/parser/bad-char-literals.rs b/src/test/ui/parser/bad-char-literals.rs index 11696b82bc9..748b4a22253 100644 --- a/src/test/ui/parser/bad-char-literals.rs +++ b/src/test/ui/parser/bad-char-literals.rs @@ -4,17 +4,17 @@ fn main() { // these literals are just silly. '''; - //~^ ERROR: character constant must be escaped: ' + //~^ ERROR: character constant must be escaped: `'` // note that this is a literal "\n" byte ' '; - //~^^ ERROR: character constant must be escaped: \n + //~^^ ERROR: character constant must be escaped: `\n` // note that this is a literal "\r" byte - ' '; //~ ERROR: character constant must be escaped: \r + ' '; //~ ERROR: character constant must be escaped: `\r` // note that this is a literal tab character here ' '; - //~^ ERROR: character constant must be escaped: \t + //~^ ERROR: character constant must be escaped: `\t` } diff --git a/src/test/ui/parser/bad-char-literals.stderr b/src/test/ui/parser/bad-char-literals.stderr index 093978fd84d..a22ddbac1b9 100644 --- a/src/test/ui/parser/bad-char-literals.stderr +++ b/src/test/ui/parser/bad-char-literals.stderr @@ -1,28 +1,28 @@ -error: character constant must be escaped: ' +error: character constant must be escaped: `'` --> $DIR/bad-char-literals.rs:6:6 | LL | '''; - | ^ + | ^ help: escape the character: `\'` -error: character constant must be escaped: \n +error: character constant must be escaped: `\n` --> $DIR/bad-char-literals.rs:10:6 | LL | ' | ______^ LL | | '; - | |_ + | |_ help: escape the character: `\n` -error: character constant must be escaped: \r +error: character constant must be escaped: `\r` --> $DIR/bad-char-literals.rs:15:6 | LL | ' '; - | ^ + | ^ help: escape the character: `\r` -error: character constant must be escaped: \t +error: character constant must be escaped: `\t` --> $DIR/bad-char-literals.rs:18:6 | LL | ' '; - | ^^^^ + | ^^^^ help: escape the character: `\t` error: aborting due to 4 previous errors diff --git a/src/test/ui/parser/byte-literals.rs b/src/test/ui/parser/byte-literals.rs index 9683a83e720..05a510b24a7 100644 --- a/src/test/ui/parser/byte-literals.rs +++ b/src/test/ui/parser/byte-literals.rs @@ -4,9 +4,9 @@ static FOO: u8 = b'\f'; //~ ERROR unknown byte escape pub fn main() { b'\f'; //~ ERROR unknown byte escape - b'\x0Z'; //~ ERROR invalid character in numeric character escape: Z + b'\x0Z'; //~ ERROR invalid character in numeric character escape: `Z` b' '; //~ ERROR byte constant must be escaped b'''; //~ ERROR byte constant must be escaped - b'é'; //~ ERROR byte constant must be ASCII + b'é'; //~ ERROR non-ASCII character in byte constant b'a //~ ERROR unterminated byte constant [E0763] } diff --git a/src/test/ui/parser/byte-literals.stderr b/src/test/ui/parser/byte-literals.stderr index 7bbdc07cd83..55be113e16b 100644 --- a/src/test/ui/parser/byte-literals.stderr +++ b/src/test/ui/parser/byte-literals.stderr @@ -1,38 +1,45 @@ -error: unknown byte escape: f +error: unknown byte escape: `f` --> $DIR/byte-literals.rs:3:21 | LL | static FOO: u8 = b'\f'; | ^ unknown byte escape + | + = help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals> -error: unknown byte escape: f +error: unknown byte escape: `f` --> $DIR/byte-literals.rs:6:8 | LL | b'\f'; | ^ unknown byte escape + | + = help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals> -error: invalid character in numeric character escape: Z +error: invalid character in numeric character escape: `Z` --> $DIR/byte-literals.rs:7:10 | LL | b'\x0Z'; - | ^ + | ^ invalid character in numeric character escape -error: byte constant must be escaped: \t +error: byte constant must be escaped: `\t` --> $DIR/byte-literals.rs:8:7 | LL | b' '; - | ^^^^ + | ^^^^ help: escape the character: `\t` -error: byte constant must be escaped: ' +error: byte constant must be escaped: `'` --> $DIR/byte-literals.rs:9:7 | LL | b'''; - | ^ + | ^ help: escape the character: `\'` -error: byte constant must be ASCII. Use a \xHH escape for a non-ASCII byte +error: non-ASCII character in byte constant --> $DIR/byte-literals.rs:10:7 | LL | b'é'; | ^ + | | + | byte constant must be ASCII + | help: use a \xHH escape for a non-ASCII byte: `\xE9` error[E0763]: unterminated byte constant --> $DIR/byte-literals.rs:11:6 diff --git a/src/test/ui/parser/byte-string-literals.rs b/src/test/ui/parser/byte-string-literals.rs index caffd9efbed..b1f11024a7b 100644 --- a/src/test/ui/parser/byte-string-literals.rs +++ b/src/test/ui/parser/byte-string-literals.rs @@ -2,7 +2,8 @@ static FOO: &'static [u8] = b"\f"; //~ ERROR unknown byte escape pub fn main() { b"\f"; //~ ERROR unknown byte escape - b"\x0Z"; //~ ERROR invalid character in numeric character escape: Z - b"é"; //~ ERROR byte constant must be ASCII + b"\x0Z"; //~ ERROR invalid character in numeric character escape: `Z` + b"é"; //~ ERROR non-ASCII character in byte constant + br##"é"##; //~ ERROR raw byte string must be ASCII b"a //~ ERROR unterminated double quote byte string } diff --git a/src/test/ui/parser/byte-string-literals.stderr b/src/test/ui/parser/byte-string-literals.stderr index 9be90644147..3a5a8b331d3 100644 --- a/src/test/ui/parser/byte-string-literals.stderr +++ b/src/test/ui/parser/byte-string-literals.stderr @@ -1,35 +1,48 @@ -error: unknown byte escape: f +error: unknown byte escape: `f` --> $DIR/byte-string-literals.rs:1:32 | LL | static FOO: &'static [u8] = b"\f"; | ^ unknown byte escape + | + = help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals> -error: unknown byte escape: f +error: unknown byte escape: `f` --> $DIR/byte-string-literals.rs:4:8 | LL | b"\f"; | ^ unknown byte escape + | + = help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals> -error: invalid character in numeric character escape: Z +error: invalid character in numeric character escape: `Z` --> $DIR/byte-string-literals.rs:5:10 | LL | b"\x0Z"; - | ^ + | ^ invalid character in numeric character escape -error: byte constant must be ASCII. Use a \xHH escape for a non-ASCII byte +error: non-ASCII character in byte constant --> $DIR/byte-string-literals.rs:6:7 | LL | b"é"; | ^ + | | + | byte constant must be ASCII + | help: use a \xHH escape for a non-ASCII byte: `\xE9` + +error: raw byte string must be ASCII + --> $DIR/byte-string-literals.rs:7:10 + | +LL | br##"é"##; + | ^ must be ASCII error[E0766]: unterminated double quote byte string - --> $DIR/byte-string-literals.rs:7:6 + --> $DIR/byte-string-literals.rs:8:6 | LL | b"a | ______^ LL | | } | |__^ -error: aborting due to 5 previous errors +error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0766`. diff --git a/src/test/ui/parser/issue-23620-invalid-escapes.rs b/src/test/ui/parser/issue-23620-invalid-escapes.rs index ab445a93294..c1355f0d6fe 100644 --- a/src/test/ui/parser/issue-23620-invalid-escapes.rs +++ b/src/test/ui/parser/issue-23620-invalid-escapes.rs @@ -1,9 +1,9 @@ fn main() { let _ = b"\u{a66e}"; - //~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string + //~^ ERROR unicode escape in byte string let _ = b'\u{a66e}'; - //~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string + //~^ ERROR unicode escape in byte string let _ = b'\u'; //~^ ERROR incorrect unicode escape sequence @@ -12,21 +12,21 @@ fn main() { //~^ ERROR numeric character escape is too short let _ = b'\xxy'; - //~^ ERROR invalid character in numeric character escape: x + //~^ ERROR invalid character in numeric character escape: `x` let _ = '\x5'; //~^ ERROR numeric character escape is too short let _ = '\xxy'; - //~^ ERROR invalid character in numeric character escape: x + //~^ ERROR invalid character in numeric character escape: `x` let _ = b"\u{a4a4} \xf \u"; - //~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string - //~^^ ERROR invalid character in numeric character escape: + //~^ ERROR unicode escape in byte string + //~^^ ERROR invalid character in numeric character escape: ` ` //~^^^ ERROR incorrect unicode escape sequence let _ = "\xf \u"; - //~^ ERROR invalid character in numeric character escape: + //~^ ERROR invalid character in numeric character escape: ` ` //~^^ ERROR incorrect unicode escape sequence let _ = "\u8f"; diff --git a/src/test/ui/parser/issue-23620-invalid-escapes.stderr b/src/test/ui/parser/issue-23620-invalid-escapes.stderr index 8c924ad0330..88d97c795fc 100644 --- a/src/test/ui/parser/issue-23620-invalid-escapes.stderr +++ b/src/test/ui/parser/issue-23620-invalid-escapes.stderr @@ -1,14 +1,18 @@ -error: unicode escape sequences cannot be used as a byte or in a byte string +error: unicode escape in byte string --> $DIR/issue-23620-invalid-escapes.rs:2:15 | LL | let _ = b"\u{a66e}"; - | ^^^^^^^^ + | ^^^^^^^^ unicode escape in byte string + | + = help: unicode escape sequences cannot be used as a byte or in a byte string -error: unicode escape sequences cannot be used as a byte or in a byte string +error: unicode escape in byte string --> $DIR/issue-23620-invalid-escapes.rs:5:15 | LL | let _ = b'\u{a66e}'; - | ^^^^^^^^ + | ^^^^^^^^ unicode escape in byte string + | + = help: unicode escape sequences cannot be used as a byte or in a byte string error: incorrect unicode escape sequence --> $DIR/issue-23620-invalid-escapes.rs:8:15 @@ -24,11 +28,11 @@ error: numeric character escape is too short LL | let _ = b'\x5'; | ^^^ -error: invalid character in numeric character escape: x +error: invalid character in numeric character escape: `x` --> $DIR/issue-23620-invalid-escapes.rs:14:17 | LL | let _ = b'\xxy'; - | ^ + | ^ invalid character in numeric character escape error: numeric character escape is too short --> $DIR/issue-23620-invalid-escapes.rs:17:14 @@ -36,23 +40,25 @@ error: numeric character escape is too short LL | let _ = '\x5'; | ^^^ -error: invalid character in numeric character escape: x +error: invalid character in numeric character escape: `x` --> $DIR/issue-23620-invalid-escapes.rs:20:16 | LL | let _ = '\xxy'; - | ^ + | ^ invalid character in numeric character escape -error: unicode escape sequences cannot be used as a byte or in a byte string +error: unicode escape in byte string --> $DIR/issue-23620-invalid-escapes.rs:23:15 | LL | let _ = b"\u{a4a4} \xf \u"; - | ^^^^^^^^ + | ^^^^^^^^ unicode escape in byte string + | + = help: unicode escape sequences cannot be used as a byte or in a byte string -error: invalid character in numeric character escape: +error: invalid character in numeric character escape: ` ` --> $DIR/issue-23620-invalid-escapes.rs:23:27 | LL | let _ = b"\u{a4a4} \xf \u"; - | ^ + | ^ invalid character in numeric character escape error: incorrect unicode escape sequence --> $DIR/issue-23620-invalid-escapes.rs:23:28 @@ -62,11 +68,11 @@ LL | let _ = b"\u{a4a4} \xf \u"; | = help: format of unicode escape sequences is `\u{...}` -error: invalid character in numeric character escape: +error: invalid character in numeric character escape: ` ` --> $DIR/issue-23620-invalid-escapes.rs:28:17 | LL | let _ = "\xf \u"; - | ^ + | ^ invalid character in numeric character escape error: incorrect unicode escape sequence --> $DIR/issue-23620-invalid-escapes.rs:28:18 diff --git a/src/test/ui/parser/issue-43692.stderr b/src/test/ui/parser/issue-43692.stderr index 69a54af3d82..baf99803517 100644 --- a/src/test/ui/parser/issue-43692.stderr +++ b/src/test/ui/parser/issue-43692.stderr @@ -1,8 +1,8 @@ -error: invalid start of unicode escape +error: invalid start of unicode escape: `_` --> $DIR/issue-43692.rs:2:9 | LL | '\u{_10FFFF}'; - | ^ + | ^ invalid start of unicode escape error: aborting due to previous error diff --git a/src/test/ui/parser/issue-62913.stderr b/src/test/ui/parser/issue-62913.stderr index f72174f8929..6f385e8dc17 100644 --- a/src/test/ui/parser/issue-62913.stderr +++ b/src/test/ui/parser/issue-62913.stderr @@ -10,7 +10,7 @@ error: invalid trailing slash in literal --> $DIR/issue-62913.rs:1:5 | LL | "\u\" - | ^ + | ^ invalid trailing slash in literal error: expected item, found `"\u\"` --> $DIR/issue-62913.rs:1:1 diff --git a/src/test/ui/parser/issue-64732.stderr b/src/test/ui/parser/issue-64732.stderr index 3b00ffc8f6c..ac042580962 100644 --- a/src/test/ui/parser/issue-64732.stderr +++ b/src/test/ui/parser/issue-64732.stderr @@ -1,13 +1,13 @@ error: character literal may only contain one codepoint - --> $DIR/issue-64732.rs:3:17 + --> $DIR/issue-64732.rs:3:16 | LL | let _foo = b'hello\0'; - | ^^^^^^^^^ + | ^^^^^^^^^^ | help: if you meant to write a byte string literal, use double quotes | LL | let _foo = b"hello\0"; - | ^^^^^^^^^ + | ^^^^^^^^^^ error: character literal may only contain one codepoint --> $DIR/issue-64732.rs:6:16 diff --git a/src/test/ui/parser/lex-bad-char-literals-1.stderr b/src/test/ui/parser/lex-bad-char-literals-1.stderr index fcf4802f79b..ed129a1d133 100644 --- a/src/test/ui/parser/lex-bad-char-literals-1.stderr +++ b/src/test/ui/parser/lex-bad-char-literals-1.stderr @@ -10,17 +10,21 @@ error: numeric character escape is too short LL | "\x1" | ^^^ -error: unknown character escape: \u{25cf} +error: unknown character escape: `\u{25cf}` --> $DIR/lex-bad-char-literals-1.rs:10:7 | LL | '\●' | ^ unknown character escape + | + = help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals> -error: unknown character escape: \u{25cf} +error: unknown character escape: `\u{25cf}` --> $DIR/lex-bad-char-literals-1.rs:14:7 | LL | "\●" | ^ unknown character escape + | + = help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals> error: aborting due to 4 previous errors diff --git a/src/test/ui/parser/lex-bad-char-literals-7.rs b/src/test/ui/parser/lex-bad-char-literals-7.rs index 1580157210e..c675df2f3cc 100644 --- a/src/test/ui/parser/lex-bad-char-literals-7.rs +++ b/src/test/ui/parser/lex-bad-char-literals-7.rs @@ -2,7 +2,7 @@ fn main() { let _: char = ''; //~^ ERROR: empty character literal let _: char = '\u{}'; - //~^ ERROR: empty unicode escape (must have at least 1 hex digit) + //~^ ERROR: empty unicode escape // Next two are OK, but may befool error recovery let _ = '/'; diff --git a/src/test/ui/parser/lex-bad-char-literals-7.stderr b/src/test/ui/parser/lex-bad-char-literals-7.stderr index 70ee8087b51..255b9c68999 100644 --- a/src/test/ui/parser/lex-bad-char-literals-7.stderr +++ b/src/test/ui/parser/lex-bad-char-literals-7.stderr @@ -2,13 +2,13 @@ error: empty character literal --> $DIR/lex-bad-char-literals-7.rs:2:20 | LL | let _: char = ''; - | ^ + | ^ empty character literal -error: empty unicode escape (must have at least 1 hex digit) +error: empty unicode escape --> $DIR/lex-bad-char-literals-7.rs:4:20 | LL | let _: char = '\u{}'; - | ^^^^ + | ^^^^ this escape must have at least 1 hex digit error[E0762]: unterminated character literal --> $DIR/lex-bad-char-literals-7.rs:11:13 diff --git a/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.rs b/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.rs index 9a9f9c433e1..b7752e1f0c4 100644 --- a/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.rs +++ b/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.rs @@ -22,5 +22,5 @@ fn main() { let _s = r"bar foo"; //~ ERROR: bare CR not allowed in raw string // the following string literal has a bare CR in it - let _s = "foo\ bar"; //~ ERROR: unknown character escape: \r + let _s = "foo\ bar"; //~ ERROR: unknown character escape: `\r` } diff --git a/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.stderr b/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.stderr index 598da6b9307..1a21fed63bd 100644 --- a/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.stderr +++ b/src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.stderr @@ -22,11 +22,11 @@ error: bare CR not allowed in block doc-comment LL | /*! block doc comment with bare CR: ' ' */ | ^ -error: bare CR not allowed in string, use \r instead +error: bare CR not allowed in string, use `\r` instead --> $DIR/lex-bare-cr-string-literal-doc-comment.rs:19:18 | LL | let _s = "foo bar"; - | ^ + | ^ help: escape the character: `\r` error: bare CR not allowed in raw string --> $DIR/lex-bare-cr-string-literal-doc-comment.rs:22:19 @@ -34,7 +34,7 @@ error: bare CR not allowed in raw string LL | let _s = r"bar foo"; | ^ -error: unknown character escape: \r +error: unknown character escape: `\r` --> $DIR/lex-bare-cr-string-literal-doc-comment.rs:25:19 | LL | let _s = "foo\ bar"; diff --git a/src/test/ui/parser/macro/literals-are-validated-before-expansion.stderr b/src/test/ui/parser/macro/literals-are-validated-before-expansion.stderr index d20eb0fb30a..e874f62497e 100644 --- a/src/test/ui/parser/macro/literals-are-validated-before-expansion.stderr +++ b/src/test/ui/parser/macro/literals-are-validated-before-expansion.stderr @@ -2,7 +2,7 @@ error: invalid unicode character escape --> $DIR/literals-are-validated-before-expansion.rs:6:20 | LL | black_hole! { '\u{FFFFFF}' } - | ^^^^^^^^^^ + | ^^^^^^^^^^ invalid escape | = help: unicode escape must be at most 10FFFF @@ -10,7 +10,7 @@ error: invalid unicode character escape --> $DIR/literals-are-validated-before-expansion.rs:8:39 | LL | black_hole! { "this is surrogate: \u{DAAA}" } - | ^^^^^^^^ + | ^^^^^^^^ invalid escape | = help: unicode escape must not be a surrogate diff --git a/src/test/ui/parser/new-unicode-escapes-1.rs b/src/test/ui/parser/new-unicode-escapes-1.rs index 0e1421214d9..d6a54660ea6 100644 --- a/src/test/ui/parser/new-unicode-escapes-1.rs +++ b/src/test/ui/parser/new-unicode-escapes-1.rs @@ -1,3 +1,3 @@ pub fn main() { - let s = "\u{2603"; //~ ERROR unterminated unicode escape (needed a `}`) + let s = "\u{2603"; //~ ERROR unterminated unicode escape } diff --git a/src/test/ui/parser/new-unicode-escapes-1.stderr b/src/test/ui/parser/new-unicode-escapes-1.stderr index 22d6a0981ff..1ffdc0401e5 100644 --- a/src/test/ui/parser/new-unicode-escapes-1.stderr +++ b/src/test/ui/parser/new-unicode-escapes-1.stderr @@ -1,8 +1,13 @@ -error: unterminated unicode escape (needed a `}`) +error: unterminated unicode escape --> $DIR/new-unicode-escapes-1.rs:2:14 | LL | let s = "\u{2603"; - | ^^^^^^^ + | ^^^^^^^ missing a closing `}` + | +help: terminate the unicode escape + | +LL | let s = "\u{2603}"; + | ^ error: aborting due to previous error diff --git a/src/test/ui/parser/new-unicode-escapes-2.rs b/src/test/ui/parser/new-unicode-escapes-2.rs index b30b3dbf903..cbb614c19c0 100644 --- a/src/test/ui/parser/new-unicode-escapes-2.rs +++ b/src/test/ui/parser/new-unicode-escapes-2.rs @@ -1,3 +1,3 @@ pub fn main() { - let s = "\u{260311111111}"; //~ ERROR overlong unicode escape (must have at most 6 hex digits) + let s = "\u{260311111111}"; //~ ERROR overlong unicode escape } diff --git a/src/test/ui/parser/new-unicode-escapes-2.stderr b/src/test/ui/parser/new-unicode-escapes-2.stderr index b5148279c74..2f3f8c0f9da 100644 --- a/src/test/ui/parser/new-unicode-escapes-2.stderr +++ b/src/test/ui/parser/new-unicode-escapes-2.stderr @@ -1,8 +1,8 @@ -error: overlong unicode escape (must have at most 6 hex digits) +error: overlong unicode escape --> $DIR/new-unicode-escapes-2.rs:2:14 | LL | let s = "\u{260311111111}"; - | ^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^ must have at most 6 hex digits error: aborting due to previous error diff --git a/src/test/ui/parser/new-unicode-escapes-3.stderr b/src/test/ui/parser/new-unicode-escapes-3.stderr index 361698467f9..f5a0f8fc785 100644 --- a/src/test/ui/parser/new-unicode-escapes-3.stderr +++ b/src/test/ui/parser/new-unicode-escapes-3.stderr @@ -2,7 +2,7 @@ error: invalid unicode character escape --> $DIR/new-unicode-escapes-3.rs:2:15 | LL | let s1 = "\u{d805}"; - | ^^^^^^^^ + | ^^^^^^^^ invalid escape | = help: unicode escape must not be a surrogate @@ -10,7 +10,7 @@ error: invalid unicode character escape --> $DIR/new-unicode-escapes-3.rs:3:15 | LL | let s2 = "\u{ffffff}"; - | ^^^^^^^^^^ + | ^^^^^^^^^^ invalid escape | = help: unicode escape must be at most 10FFFF diff --git a/src/test/ui/parser/new-unicode-escapes-4.rs b/src/test/ui/parser/new-unicode-escapes-4.rs index 9ac03cedc3f..79882713e59 100644 --- a/src/test/ui/parser/new-unicode-escapes-4.rs +++ b/src/test/ui/parser/new-unicode-escapes-4.rs @@ -1,4 +1,4 @@ pub fn main() { let s = "\u{lol}"; - //~^ ERROR invalid character in unicode escape: l + //~^ ERROR invalid character in unicode escape: `l` } diff --git a/src/test/ui/parser/new-unicode-escapes-4.stderr b/src/test/ui/parser/new-unicode-escapes-4.stderr index a35c5f0f216..514591af17e 100644 --- a/src/test/ui/parser/new-unicode-escapes-4.stderr +++ b/src/test/ui/parser/new-unicode-escapes-4.stderr @@ -1,8 +1,8 @@ -error: invalid character in unicode escape: l +error: invalid character in unicode escape: `l` --> $DIR/new-unicode-escapes-4.rs:2:17 | LL | let s = "\u{lol}"; - | ^ + | ^ invalid character in unicode escape error: aborting due to previous error diff --git a/src/test/ui/parser/raw/raw-byte-string-literals.stderr b/src/test/ui/parser/raw/raw-byte-string-literals.stderr index 4076fe334e6..cfc877104bd 100644 --- a/src/test/ui/parser/raw/raw-byte-string-literals.stderr +++ b/src/test/ui/parser/raw/raw-byte-string-literals.stderr @@ -8,7 +8,7 @@ error: raw byte string must be ASCII --> $DIR/raw-byte-string-literals.rs:5:8 | LL | br"é"; - | ^ + | ^ must be ASCII error: found invalid character; only `#` is allowed in raw string delimitation: ~ --> $DIR/raw-byte-string-literals.rs:6:5 diff --git a/src/test/ui/parser/trailing-carriage-return-in-string.rs b/src/test/ui/parser/trailing-carriage-return-in-string.rs index 8abf2624e4f..5d3c3194406 100644 --- a/src/test/ui/parser/trailing-carriage-return-in-string.rs +++ b/src/test/ui/parser/trailing-carriage-return-in-string.rs @@ -8,7 +8,7 @@ fn main() { a test"; // \r only let bad = "This is \ a test"; - //~^ ERROR unknown character escape: \r - //~^^ HELP this is an isolated carriage return + //~^ ERROR unknown character escape: `\r` + //~| HELP this is an isolated carriage return } diff --git a/src/test/ui/parser/trailing-carriage-return-in-string.stderr b/src/test/ui/parser/trailing-carriage-return-in-string.stderr index 3687b9dd282..8a44e02707c 100644 --- a/src/test/ui/parser/trailing-carriage-return-in-string.stderr +++ b/src/test/ui/parser/trailing-carriage-return-in-string.stderr @@ -1,4 +1,4 @@ -error: unknown character escape: \r +error: unknown character escape: `\r` --> $DIR/trailing-carriage-return-in-string.rs:10:25 | LL | let bad = "This is \ a test"; diff --git a/src/test/ui/parser/unclosed-delimiter-in-dep.stderr b/src/test/ui/parser/unclosed-delimiter-in-dep.stderr index d63a50034c5..00861a5a3d4 100644 --- a/src/test/ui/parser/unclosed-delimiter-in-dep.stderr +++ b/src/test/ui/parser/unclosed-delimiter-in-dep.stderr @@ -13,12 +13,12 @@ error[E0308]: mismatched types --> $DIR/unclosed-delimiter-in-dep.rs:4:20 | LL | let _: usize = unclosed_delim_mod::new(); - | ----- ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found enum `std::result::Result` + | ----- ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found enum `Result` | | | expected due to this | = note: expected type `usize` - found enum `std::result::Result<Value, ()>` + found enum `Result<Value, ()>` error: aborting due to 2 previous errors diff --git a/src/test/ui/parser/wrong-escape-of-curly-braces.rs b/src/test/ui/parser/wrong-escape-of-curly-braces.rs index 7a5c27afca5..8e5258acd49 100644 --- a/src/test/ui/parser/wrong-escape-of-curly-braces.rs +++ b/src/test/ui/parser/wrong-escape-of-curly-braces.rs @@ -1,8 +1,8 @@ fn main() { let ok = "{{everything fine}}"; let bad = "\{it is wrong\}"; - //~^ ERROR unknown character escape: { - //~^^ HELP if used in a formatting string, curly braces are escaped with `{{` and `}}` - //~^^^ ERROR unknown character escape: } - //~^^^^ HELP if used in a formatting string, curly braces are escaped with `{{` and `}}` + //~^ ERROR unknown character escape: `{` + //~| HELP if used in a formatting string, curly braces are escaped with `{{` and `}}` + //~| ERROR unknown character escape: `}` + //~| HELP if used in a formatting string, curly braces are escaped with `{{` and `}}` } diff --git a/src/test/ui/parser/wrong-escape-of-curly-braces.stderr b/src/test/ui/parser/wrong-escape-of-curly-braces.stderr index 1406b795ba8..ff1a2fb0f3c 100644 --- a/src/test/ui/parser/wrong-escape-of-curly-braces.stderr +++ b/src/test/ui/parser/wrong-escape-of-curly-braces.stderr @@ -1,4 +1,4 @@ -error: unknown character escape: { +error: unknown character escape: `{` --> $DIR/wrong-escape-of-curly-braces.rs:3:17 | LL | let bad = "\{it is wrong\}"; @@ -6,7 +6,7 @@ LL | let bad = "\{it is wrong\}"; | = help: if used in a formatting string, curly braces are escaped with `{{` and `}}` -error: unknown character escape: } +error: unknown character escape: `}` --> $DIR/wrong-escape-of-curly-braces.rs:3:30 | LL | let bad = "\{it is wrong\}"; diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr index bfb7b479731..ff8183e8763 100644 --- a/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr +++ b/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr @@ -33,7 +33,7 @@ error[E0382]: use of moved value --> $DIR/borrowck-move-and-move.rs:20:16 | LL | match Ok(U) { - | ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait + | ----- move occurs because value has type `Result<U, U>`, which does not implement the `Copy` trait LL | a @ Ok(b) | a @ Err(b) => {} | -------^- | | | @@ -44,7 +44,7 @@ error[E0382]: use of moved value --> $DIR/borrowck-move-and-move.rs:20:29 | LL | match Ok(U) { - | ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait + | ----- move occurs because value has type `Result<U, U>`, which does not implement the `Copy` trait LL | a @ Ok(b) | a @ Err(b) => {} | --------^- | | | diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr index 00136c25764..13032c3838a 100644 --- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr +++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr @@ -390,7 +390,7 @@ error[E0507]: cannot move out of `a` in pattern guard --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66 | LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {} - | ^ move occurs because `a` has type `&mut std::result::Result<U, U>`, which does not implement the `Copy` trait + | ^ move occurs because `a` has type `&mut Result<U, U>`, which does not implement the `Copy` trait | = note: variables bound in patterns cannot be moved from until after the end of the pattern guard @@ -398,7 +398,7 @@ error[E0507]: cannot move out of `a` in pattern guard --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66 | LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {} - | ^ move occurs because `a` has type `&mut std::result::Result<U, U>`, which does not implement the `Copy` trait + | ^ move occurs because `a` has type `&mut Result<U, U>`, which does not implement the `Copy` trait | = note: variables bound in patterns cannot be moved from until after the end of the pattern guard diff --git a/src/test/ui/pattern/pat-struct-field-expr-has-type.stderr b/src/test/ui/pattern/pat-struct-field-expr-has-type.stderr index d57a8a0dbc1..3a61d4293b0 100644 --- a/src/test/ui/pattern/pat-struct-field-expr-has-type.stderr +++ b/src/test/ui/pattern/pat-struct-field-expr-has-type.stderr @@ -4,10 +4,10 @@ error[E0308]: mismatched types LL | match (S { f: 42 }) { | ------------- this expression has type `S` LL | S { f: Ok(_) } => {} - | ^^^^^ expected `u8`, found enum `std::result::Result` + | ^^^^^ expected `u8`, found enum `Result` | = note: expected type `u8` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error: aborting due to previous error diff --git a/src/test/ui/pattern/pat-type-err-let-stmt.stderr b/src/test/ui/pattern/pat-type-err-let-stmt.stderr index 42258cfc1ae..4b4fb089283 100644 --- a/src/test/ui/pattern/pat-type-err-let-stmt.stderr +++ b/src/test/ui/pattern/pat-type-err-let-stmt.stderr @@ -17,10 +17,10 @@ error[E0308]: mismatched types LL | let Ok(0): Option<u8> = 42u8; | ^^^^^ ---------- expected due to this | | - | expected enum `Option`, found enum `std::result::Result` + | expected enum `Option`, found enum `Result` | = note: expected enum `Option<u8>` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error[E0308]: mismatched types --> $DIR/pat-type-err-let-stmt.rs:11:9 @@ -28,10 +28,10 @@ error[E0308]: mismatched types LL | let Ok(0): Option<u8>; | ^^^^^ ---------- expected due to this | | - | expected enum `Option`, found enum `std::result::Result` + | expected enum `Option`, found enum `Result` | = note: expected enum `Option<u8>` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error[E0308]: mismatched types --> $DIR/pat-type-err-let-stmt.rs:15:9 @@ -39,10 +39,10 @@ error[E0308]: mismatched types LL | let Ok(0) = 42u8; | ^^^^^ ---- this expression has type `u8` | | - | expected `u8`, found enum `std::result::Result` + | expected `u8`, found enum `Result` | = note: expected type `u8` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error: aborting due to 4 previous errors diff --git a/src/test/ui/pattern/usefulness/issue-80501-or-pat-and-macro.rs b/src/test/ui/pattern/usefulness/issue-80501-or-pat-and-macro.rs new file mode 100644 index 00000000000..aac7d7d5385 --- /dev/null +++ b/src/test/ui/pattern/usefulness/issue-80501-or-pat-and-macro.rs @@ -0,0 +1,27 @@ +// check-pass +#![deny(unreachable_patterns)] +pub enum TypeCtor { + Slice, + Array, +} + +pub struct ApplicationTy(TypeCtor); + +macro_rules! ty_app { + ($ctor:pat) => { + ApplicationTy($ctor) + }; +} + +fn _foo(ty: ApplicationTy) { + match ty { + ty_app!(TypeCtor::Array) | ty_app!(TypeCtor::Slice) => {} + } + + // same as above, with the macro expanded + match ty { + ApplicationTy(TypeCtor::Array) | ApplicationTy(TypeCtor::Slice) => {} + } +} + +fn main() {} diff --git a/src/test/ui/pattern/usefulness/non-exhaustive-match-nested.stderr b/src/test/ui/pattern/usefulness/non-exhaustive-match-nested.stderr index d1cab752102..928e9068266 100644 --- a/src/test/ui/pattern/usefulness/non-exhaustive-match-nested.stderr +++ b/src/test/ui/pattern/usefulness/non-exhaustive-match-nested.stderr @@ -5,7 +5,7 @@ LL | match (l1, l2) { | ^^^^^^^^ pattern `(Some(&[]), Err(_))` not covered | = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms - = note: the matched value is of type `(Option<&[T]>, std::result::Result<&[T], ()>)` + = note: the matched value is of type `(Option<&[T]>, Result<&[T], ()>)` error[E0004]: non-exhaustive patterns: `A(C)` not covered --> $DIR/non-exhaustive-match-nested.rs:15:11 diff --git a/src/test/ui/proc-macro/attribute-after-derive-feature-gate.rs b/src/test/ui/proc-macro/attribute-after-derive-feature-gate.rs new file mode 100644 index 00000000000..f0fec678242 --- /dev/null +++ b/src/test/ui/proc-macro/attribute-after-derive-feature-gate.rs @@ -0,0 +1,37 @@ +// gate-test-macro_attributes_in_derive_output +// aux-build: test-macros.rs + +#![feature(proc_macro_hygiene)] +#![feature(stmt_expr_attributes)] + +#[macro_use] +extern crate test_macros; + +#[derive(Empty)] +#[empty_attr] //~ ERROR macro attributes in `#[derive]` output are unstable +struct S1 { + field: [u8; 10], +} + +#[derive(Empty)] +#[empty_helper] +#[empty_attr] //~ ERROR macro attributes in `#[derive]` output are unstable +struct S2 { + field: [u8; 10], +} + +#[derive(Empty)] +struct S3 { + field: [u8; #[identity_attr] 10], //~ ERROR macro attributes in `#[derive]` output are unstable +} + +#[derive(Empty)] +struct S4 { + field: [u8; { + #[derive(Empty)] // OK, not gated + struct Inner; + 10 + }] +} + +fn main() {} diff --git a/src/test/ui/proc-macro/attribute-after-derive-feature-gate.stderr b/src/test/ui/proc-macro/attribute-after-derive-feature-gate.stderr new file mode 100644 index 00000000000..74cace628b9 --- /dev/null +++ b/src/test/ui/proc-macro/attribute-after-derive-feature-gate.stderr @@ -0,0 +1,30 @@ +error[E0658]: macro attributes in `#[derive]` output are unstable + --> $DIR/attribute-after-derive-feature-gate.rs:11:3 + | +LL | #[empty_attr] + | ^^^^^^^^^^ + | + = note: see issue #81119 <https://github.com/rust-lang/rust/issues/81119> for more information + = help: add `#![feature(macro_attributes_in_derive_output)]` to the crate attributes to enable + +error[E0658]: macro attributes in `#[derive]` output are unstable + --> $DIR/attribute-after-derive-feature-gate.rs:18:3 + | +LL | #[empty_attr] + | ^^^^^^^^^^ + | + = note: see issue #81119 <https://github.com/rust-lang/rust/issues/81119> for more information + = help: add `#![feature(macro_attributes_in_derive_output)]` to the crate attributes to enable + +error[E0658]: macro attributes in `#[derive]` output are unstable + --> $DIR/attribute-after-derive-feature-gate.rs:25:19 + | +LL | field: [u8; #[identity_attr] 10], + | ^^^^^^^^^^^^^ + | + = note: see issue #81119 <https://github.com/rust-lang/rust/issues/81119> for more information + = help: add `#![feature(macro_attributes_in_derive_output)]` to the crate attributes to enable + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0658`. diff --git a/src/test/ui/proc-macro/attribute-after-derive.rs b/src/test/ui/proc-macro/attribute-after-derive.rs new file mode 100644 index 00000000000..ac3f28b6ef3 --- /dev/null +++ b/src/test/ui/proc-macro/attribute-after-derive.rs @@ -0,0 +1,30 @@ +// Macro attributes are allowed after `#[derive]` and +// `#[derive]` fully configures the item for following attributes. + +// check-pass +// compile-flags: -Z span-debug +// aux-build: test-macros.rs + +#![feature(macro_attributes_in_derive_output)] + +#![no_std] // Don't load unnecessary hygiene information from std +extern crate std; + +#[macro_use] +extern crate test_macros; + +#[print_attr] +#[derive(Print)] +struct AttributeDerive { + #[cfg(FALSE)] + field: u8, +} + +#[derive(Print)] +#[print_attr] +struct DeriveAttribute { + #[cfg(FALSE)] + field: u8, +} + +fn main() {} diff --git a/src/test/ui/proc-macro/attribute-after-derive.stdout b/src/test/ui/proc-macro/attribute-after-derive.stdout new file mode 100644 index 00000000000..11f49235327 --- /dev/null +++ b/src/test/ui/proc-macro/attribute-after-derive.stdout @@ -0,0 +1,148 @@ +PRINT-ATTR INPUT (DISPLAY): #[derive(Print)] struct AttributeDerive { #[cfg(FALSE)] field : u8, } +PRINT-ATTR INPUT (DEBUG): TokenStream [ + Punct { + ch: '#', + spacing: Alone, + span: $DIR/attribute-after-derive.rs:17:1: 17:2 (#0), + }, + Group { + delimiter: Bracket, + stream: TokenStream [ + Ident { + ident: "derive", + span: $DIR/attribute-after-derive.rs:17:3: 17:9 (#0), + }, + Group { + delimiter: Parenthesis, + stream: TokenStream [ + Ident { + ident: "Print", + span: $DIR/attribute-after-derive.rs:17:10: 17:15 (#0), + }, + ], + span: $DIR/attribute-after-derive.rs:17:9: 17:16 (#0), + }, + ], + span: $DIR/attribute-after-derive.rs:17:2: 17:17 (#0), + }, + Ident { + ident: "struct", + span: $DIR/attribute-after-derive.rs:18:1: 18:7 (#0), + }, + Ident { + ident: "AttributeDerive", + span: $DIR/attribute-after-derive.rs:18:8: 18:23 (#0), + }, + Group { + delimiter: Brace, + stream: TokenStream [ + Punct { + ch: '#', + spacing: Alone, + span: $DIR/attribute-after-derive.rs:19:5: 19:6 (#0), + }, + Group { + delimiter: Bracket, + stream: TokenStream [ + Ident { + ident: "cfg", + span: $DIR/attribute-after-derive.rs:19:7: 19:10 (#0), + }, + Group { + delimiter: Parenthesis, + stream: TokenStream [ + Ident { + ident: "FALSE", + span: $DIR/attribute-after-derive.rs:19:11: 19:16 (#0), + }, + ], + span: $DIR/attribute-after-derive.rs:19:10: 19:17 (#0), + }, + ], + span: $DIR/attribute-after-derive.rs:19:6: 19:18 (#0), + }, + Ident { + ident: "field", + span: $DIR/attribute-after-derive.rs:20:5: 20:10 (#0), + }, + Punct { + ch: ':', + spacing: Alone, + span: $DIR/attribute-after-derive.rs:20:10: 20:11 (#0), + }, + Ident { + ident: "u8", + span: $DIR/attribute-after-derive.rs:20:12: 20:14 (#0), + }, + Punct { + ch: ',', + spacing: Alone, + span: $DIR/attribute-after-derive.rs:20:14: 20:15 (#0), + }, + ], + span: $DIR/attribute-after-derive.rs:18:24: 21:2 (#0), + }, +] +PRINT-DERIVE INPUT (DISPLAY): struct AttributeDerive { } +PRINT-DERIVE INPUT (DEBUG): TokenStream [ + Ident { + ident: "struct", + span: $DIR/attribute-after-derive.rs:18:1: 21:2 (#0), + }, + Ident { + ident: "AttributeDerive", + span: $DIR/attribute-after-derive.rs:18:1: 21:2 (#0), + }, + Group { + delimiter: Brace, + stream: TokenStream [], + span: $DIR/attribute-after-derive.rs:18:1: 21:2 (#0), + }, +] +PRINT-ATTR INPUT (DISPLAY): struct DeriveAttribute { } +PRINT-ATTR INPUT (DEBUG): TokenStream [ + Ident { + ident: "struct", + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, + Ident { + ident: "DeriveAttribute", + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, + Group { + delimiter: Brace, + stream: TokenStream [], + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, +] +PRINT-DERIVE INPUT (DISPLAY): #[print_attr] struct DeriveAttribute { } +PRINT-DERIVE INPUT (DEBUG): TokenStream [ + Punct { + ch: '#', + spacing: Alone, + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, + Group { + delimiter: Bracket, + stream: TokenStream [ + Ident { + ident: "print_attr", + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, + ], + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, + Ident { + ident: "struct", + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, + Ident { + ident: "DeriveAttribute", + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, + Group { + delimiter: Brace, + stream: TokenStream [], + span: $DIR/attribute-after-derive.rs:25:1: 28:2 (#0), + }, +] diff --git a/src/test/ui/proc-macro/attribute-order-restricted.rs b/src/test/ui/proc-macro/attribute-order-restricted.rs deleted file mode 100644 index a3d4d23450c..00000000000 --- a/src/test/ui/proc-macro/attribute-order-restricted.rs +++ /dev/null @@ -1,14 +0,0 @@ -// aux-build:test-macros.rs - -#[macro_use] -extern crate test_macros; - -#[identity_attr] // OK -#[derive(Clone)] -struct Before; - -#[derive(Clone)] -#[identity_attr] //~ ERROR macro attributes must be placed before `#[derive]` -struct After; - -fn main() {} diff --git a/src/test/ui/proc-macro/attribute-order-restricted.stderr b/src/test/ui/proc-macro/attribute-order-restricted.stderr deleted file mode 100644 index 9ca8a443e40..00000000000 --- a/src/test/ui/proc-macro/attribute-order-restricted.stderr +++ /dev/null @@ -1,8 +0,0 @@ -error: macro attributes must be placed before `#[derive]` - --> $DIR/attribute-order-restricted.rs:11:1 - | -LL | #[identity_attr] - | ^^^^^^^^^^^^^^^^ - -error: aborting due to previous error - diff --git a/src/test/ui/proc-macro/derive-helper-legacy-limits.rs b/src/test/ui/proc-macro/derive-helper-legacy-limits.rs new file mode 100644 index 00000000000..ca904900da0 --- /dev/null +++ b/src/test/ui/proc-macro/derive-helper-legacy-limits.rs @@ -0,0 +1,21 @@ +// Support for legacy derive helpers is limited and heuristic-based +// (that's exactly the reason why they are deprecated). + +// edition:2018 +// aux-build:test-macros.rs + +#[macro_use] +extern crate test_macros; + +use derive as my_derive; + +#[my_derive(Empty)] +#[empty_helper] // OK +struct S1; + +// Legacy helper detection doesn't see through `derive` renaming. +#[empty_helper] //~ ERROR cannot find attribute `empty_helper` in this scope +#[my_derive(Empty)] +struct S2; + +fn main() {} diff --git a/src/test/ui/proc-macro/derive-helper-legacy-limits.stderr b/src/test/ui/proc-macro/derive-helper-legacy-limits.stderr new file mode 100644 index 00000000000..186f38a00f9 --- /dev/null +++ b/src/test/ui/proc-macro/derive-helper-legacy-limits.stderr @@ -0,0 +1,8 @@ +error: cannot find attribute `empty_helper` in this scope + --> $DIR/derive-helper-legacy-limits.rs:17:3 + | +LL | #[empty_helper] + | ^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/proc-macro/derive-helper-shadowing.rs b/src/test/ui/proc-macro/derive-helper-shadowing.rs index 6147e96a74b..80d982d2504 100644 --- a/src/test/ui/proc-macro/derive-helper-shadowing.rs +++ b/src/test/ui/proc-macro/derive-helper-shadowing.rs @@ -17,6 +17,8 @@ macro_rules! gen_helper_use { } #[empty_helper] //~ ERROR `empty_helper` is ambiguous + //~| WARN derive helper attribute is used before it is introduced + //~| WARN this was previously accepted #[derive(Empty)] struct S { #[empty_helper] // OK, no ambiguity, derive helpers have highest priority diff --git a/src/test/ui/proc-macro/derive-helper-shadowing.stderr b/src/test/ui/proc-macro/derive-helper-shadowing.stderr index f82f49aa775..a49df9f2d4a 100644 --- a/src/test/ui/proc-macro/derive-helper-shadowing.stderr +++ b/src/test/ui/proc-macro/derive-helper-shadowing.stderr @@ -1,17 +1,17 @@ error: cannot use a derive helper attribute through an import - --> $DIR/derive-helper-shadowing.rs:40:15 + --> $DIR/derive-helper-shadowing.rs:42:15 | LL | #[renamed] | ^^^^^^^ | note: the derive helper attribute imported here - --> $DIR/derive-helper-shadowing.rs:39:17 + --> $DIR/derive-helper-shadowing.rs:41:17 | LL | use empty_helper as renamed; | ^^^^^^^^^^^^^^^^^^^^^^^ error: cannot find attribute `empty_helper` in this scope - --> $DIR/derive-helper-shadowing.rs:36:22 + --> $DIR/derive-helper-shadowing.rs:38:22 | LL | #[derive(GenHelperUse)] | ^^^^^^^^^^^^ @@ -30,13 +30,13 @@ LL | gen_helper_use!(); = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info) error[E0659]: `empty_helper` is ambiguous (name vs any other name during import resolution) - --> $DIR/derive-helper-shadowing.rs:24:13 + --> $DIR/derive-helper-shadowing.rs:26:13 | LL | use empty_helper; | ^^^^^^^^^^^^ ambiguous name | note: `empty_helper` could refer to the derive helper attribute defined here - --> $DIR/derive-helper-shadowing.rs:20:10 + --> $DIR/derive-helper-shadowing.rs:22:10 | LL | #[derive(Empty)] | ^^^^^ @@ -54,7 +54,7 @@ LL | #[empty_helper] | ^^^^^^^^^^^^ ambiguous name | note: `empty_helper` could refer to the derive helper attribute defined here - --> $DIR/derive-helper-shadowing.rs:20:10 + --> $DIR/derive-helper-shadowing.rs:22:10 | LL | #[derive(Empty)] | ^^^^^ @@ -65,6 +65,19 @@ LL | use test_macros::empty_attr as empty_helper; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = help: use `crate::empty_helper` to refer to this attribute macro unambiguously -error: aborting due to 5 previous errors +warning: derive helper attribute is used before it is introduced + --> $DIR/derive-helper-shadowing.rs:19:3 + | +LL | #[empty_helper] + | ^^^^^^^^^^^^ +... +LL | #[derive(Empty)] + | ----- the attribute is introduced here + | + = note: `#[warn(legacy_derive_helpers)]` 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 #79202 <https://github.com/rust-lang/rust/issues/79202> + +error: aborting due to 5 previous errors; 1 warning emitted For more information about this error, try `rustc --explain E0659`. diff --git a/src/test/ui/proc-macro/derive-helper-vs-legacy.rs b/src/test/ui/proc-macro/derive-helper-vs-legacy.rs new file mode 100644 index 00000000000..98836bcb893 --- /dev/null +++ b/src/test/ui/proc-macro/derive-helper-vs-legacy.rs @@ -0,0 +1,12 @@ +// check-pass +// aux-build:test-macros.rs + +#[macro_use] +extern crate test_macros; + +#[derive(Empty)] +#[empty_helper] // OK, this is both derive helper and legacy derive helper +#[derive(Empty)] +struct S; + +fn main() {} diff --git a/src/test/ui/proc-macro/derive-multiple-with-packed.rs b/src/test/ui/proc-macro/derive-multiple-with-packed.rs new file mode 100644 index 00000000000..23578aa0e9f --- /dev/null +++ b/src/test/ui/proc-macro/derive-multiple-with-packed.rs @@ -0,0 +1,11 @@ +// check-pass + +#[derive(Clone, Copy)] +#[derive(Debug)] // OK, even if `Copy` is in the different `#[derive]` +#[derive(PartialEq)] // OK too +#[repr(packed)] +struct CacheRecordHeader { + field: u64, +} + +fn main() {} diff --git a/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs b/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs index 3a1c56efce8..40c42d82f68 100644 --- a/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs +++ b/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs @@ -4,8 +4,10 @@ extern crate test_macros; use test_macros::empty_attr as empty_helper; -#[derive(Empty)] #[empty_helper] //~ ERROR `empty_helper` is ambiguous + //~| WARN derive helper attribute is used before it is introduced + //~| WARN this was previously accepted +#[derive(Empty)] struct S; fn main() {} diff --git a/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr b/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr index 012fb105b12..ceb6d789785 100644 --- a/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr +++ b/src/test/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr @@ -1,11 +1,11 @@ error[E0659]: `empty_helper` is ambiguous (derive helper attribute vs any other name) - --> $DIR/helper-attr-blocked-by-import-ambig.rs:8:3 + --> $DIR/helper-attr-blocked-by-import-ambig.rs:7:3 | LL | #[empty_helper] | ^^^^^^^^^^^^ ambiguous name | note: `empty_helper` could refer to the derive helper attribute defined here - --> $DIR/helper-attr-blocked-by-import-ambig.rs:7:10 + --> $DIR/helper-attr-blocked-by-import-ambig.rs:10:10 | LL | #[derive(Empty)] | ^^^^^ @@ -16,6 +16,19 @@ LL | use test_macros::empty_attr as empty_helper; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = help: use `crate::empty_helper` to refer to this attribute macro unambiguously -error: aborting due to previous error +warning: derive helper attribute is used before it is introduced + --> $DIR/helper-attr-blocked-by-import-ambig.rs:7:3 + | +LL | #[empty_helper] + | ^^^^^^^^^^^^ +... +LL | #[derive(Empty)] + | ----- the attribute is introduced here + | + = note: `#[warn(legacy_derive_helpers)]` 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 #79202 <https://github.com/rust-lang/rust/issues/79202> + +error: aborting due to previous error; 1 warning emitted For more information about this error, try `rustc --explain E0659`. diff --git a/src/test/ui/proc-macro/issue-75930-derive-cfg.rs b/src/test/ui/proc-macro/issue-75930-derive-cfg.rs index a051d23bac0..649e7318403 100644 --- a/src/test/ui/proc-macro/issue-75930-derive-cfg.rs +++ b/src/test/ui/proc-macro/issue-75930-derive-cfg.rs @@ -13,7 +13,8 @@ #[macro_use] extern crate test_macros; -#[print_helper(a)] +#[print_helper(a)] //~ WARN derive helper attribute is used before it is introduced + //~| WARN this was previously accepted #[cfg_attr(not(FALSE), allow(dead_code))] #[print_attr] #[derive(Print)] diff --git a/src/test/ui/proc-macro/issue-75930-derive-cfg.stderr b/src/test/ui/proc-macro/issue-75930-derive-cfg.stderr new file mode 100644 index 00000000000..5227da7d766 --- /dev/null +++ b/src/test/ui/proc-macro/issue-75930-derive-cfg.stderr @@ -0,0 +1,15 @@ +warning: derive helper attribute is used before it is introduced + --> $DIR/issue-75930-derive-cfg.rs:16:3 + | +LL | #[print_helper(a)] + | ^^^^^^^^^^^^ +... +LL | #[derive(Print)] + | ----- the attribute is introduced here + | + = note: `#[warn(legacy_derive_helpers)]` 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 #79202 <https://github.com/rust-lang/rust/issues/79202> + +warning: 1 warning emitted + diff --git a/src/test/ui/proc-macro/issue-75930-derive-cfg.stdout b/src/test/ui/proc-macro/issue-75930-derive-cfg.stdout index 5f513684cfa..19aa4dfb60e 100644 --- a/src/test/ui/proc-macro/issue-75930-derive-cfg.stdout +++ b/src/test/ui/proc-macro/issue-75930-derive-cfg.stdout @@ -26,77 +26,77 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:17:1: 17:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:18:1: 18:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "allow", - span: $DIR/issue-75930-derive-cfg.rs:17:24: 17:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:18:24: 18:29 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "dead_code", - span: $DIR/issue-75930-derive-cfg.rs:17:30: 17:39 (#0), + span: $DIR/issue-75930-derive-cfg.rs:18:30: 18:39 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:17:29: 17:40 (#0), + span: $DIR/issue-75930-derive-cfg.rs:18:29: 18:40 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:17:1: 17:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:18:1: 18:2 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:19:1: 19:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:20:1: 20:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "derive", - span: $DIR/issue-75930-derive-cfg.rs:19:3: 19:9 (#0), + span: $DIR/issue-75930-derive-cfg.rs:20:3: 20:9 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "Print", - span: $DIR/issue-75930-derive-cfg.rs:19:10: 19:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:20:10: 20:15 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:19:9: 19:16 (#0), + span: $DIR/issue-75930-derive-cfg.rs:20:9: 20:16 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:19:2: 19:17 (#0), + span: $DIR/issue-75930-derive-cfg.rs:20:2: 20:17 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:20:1: 20:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:21:1: 21:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:20:3: 20:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:21:3: 21:15 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "b", - span: $DIR/issue-75930-derive-cfg.rs:20:16: 20:17 (#0), + span: $DIR/issue-75930-derive-cfg.rs:21:16: 21:17 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:20:15: 20:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:21:15: 21:18 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:20:2: 20:19 (#0), + span: $DIR/issue-75930-derive-cfg.rs:21:2: 21:19 (#0), }, Punct { ch: '#', @@ -125,59 +125,59 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ }, Ident { ident: "struct", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 21:7 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 22:7 (#0), }, Ident { ident: "Foo", - span: $DIR/issue-75930-derive-cfg.rs:21:8: 21:11 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:8: 22:11 (#0), }, Punct { ch: '<', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:21:11: 21:12 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:11: 22:12 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:12: 21:13 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:12: 22:13 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:21:14: 21:17 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:14: 22:17 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:21:18: 21:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:18: 22:23 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:17: 21:24 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:17: 22:24 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:13: 21:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:13: 22:25 (#0), }, Ident { ident: "A", - span: $DIR/issue-75930-derive-cfg.rs:21:26: 21:27 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:26: 22:27 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:27: 21:28 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:27: 22:28 (#0), }, Ident { ident: "B", - span: $DIR/issue-75930-derive-cfg.rs:21:29: 21:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:29: 22:30 (#0), }, Punct { ch: '>', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:30: 21:31 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:30: 22:31 (#0), }, Group { delimiter: Brace, @@ -185,128 +185,128 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:22:5: 22:6 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:5: 23:6 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:22:7: 22:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:7: 23:10 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:22:11: 22:16 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:11: 23:16 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:22:10: 22:17 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:10: 23:17 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:22:6: 22:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:6: 23:18 (#0), }, Ident { ident: "first", - span: $DIR/issue-75930-derive-cfg.rs:22:19: 22:24 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:19: 23:24 (#0), }, Punct { ch: ':', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:22:24: 22:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:24: 23:25 (#0), }, Ident { ident: "String", - span: $DIR/issue-75930-derive-cfg.rs:22:26: 22:32 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:26: 23:32 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:22:32: 22:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:23:32: 23:33 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:23:5: 23:6 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:5: 24:6 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg_attr", - span: $DIR/issue-75930-derive-cfg.rs:23:7: 23:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:7: 24:15 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:23:16: 23:21 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:16: 24:21 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:23:21: 23:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:21: 24:22 (#0), }, Ident { ident: "deny", - span: $DIR/issue-75930-derive-cfg.rs:23:23: 23:27 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:23: 24:27 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "warnings", - span: $DIR/issue-75930-derive-cfg.rs:23:28: 23:36 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:28: 24:36 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:23:27: 23:37 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:27: 24:37 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:23:15: 23:38 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:15: 24:38 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:23:6: 23:39 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:6: 24:39 (#0), }, Ident { ident: "second", - span: $DIR/issue-75930-derive-cfg.rs:23:40: 23:46 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:40: 24:46 (#0), }, Punct { ch: ':', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:23:46: 23:47 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:46: 24:47 (#0), }, Ident { ident: "bool", - span: $DIR/issue-75930-derive-cfg.rs:23:48: 23:52 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:48: 24:52 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:23:52: 23:53 (#0), + span: $DIR/issue-75930-derive-cfg.rs:24:52: 24:53 (#0), }, Ident { ident: "third", - span: $DIR/issue-75930-derive-cfg.rs:24:5: 24:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:25:5: 25:10 (#0), }, Punct { ch: ':', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:24:10: 24:11 (#0), + span: $DIR/issue-75930-derive-cfg.rs:25:10: 25:11 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "u8", - span: $DIR/issue-75930-derive-cfg.rs:24:13: 24:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:25:13: 25:15 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:24:15: 24:16 (#0), + span: $DIR/issue-75930-derive-cfg.rs:25:15: 25:16 (#0), }, Group { delimiter: Brace, @@ -314,145 +314,145 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:25:9: 25:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:9: 26:10 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:25:11: 25:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:11: 26:14 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:25:15: 25:20 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:15: 26:20 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:25:14: 25:21 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:14: 26:21 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:25:10: 25:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:10: 26:22 (#0), }, Ident { ident: "struct", - span: $DIR/issue-75930-derive-cfg.rs:25:23: 25:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:23: 26:29 (#0), }, Ident { ident: "Bar", - span: $DIR/issue-75930-derive-cfg.rs:25:30: 25:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:30: 26:33 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:25:33: 25:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:26:33: 26:34 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:26:9: 26:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:9: 27:10 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:26:11: 26:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:11: 27:14 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:26:15: 26:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:15: 27:18 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:26:19: 26:24 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:19: 27:24 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:26:18: 26:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:18: 27:25 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:26:14: 26:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:14: 27:26 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:26:10: 26:27 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:10: 27:27 (#0), }, Ident { ident: "struct", - span: $DIR/issue-75930-derive-cfg.rs:26:28: 26:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:28: 27:34 (#0), }, Ident { ident: "Inner", - span: $DIR/issue-75930-derive-cfg.rs:26:35: 26:40 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:35: 27:40 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:26:40: 26:41 (#0), + span: $DIR/issue-75930-derive-cfg.rs:27:40: 27:41 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:27:9: 27:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:9: 28:10 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:27:11: 27:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:11: 28:14 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:27:15: 27:20 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:15: 28:20 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:27:14: 27:21 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:14: 28:21 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:27:10: 27:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:10: 28:22 (#0), }, Ident { ident: "let", - span: $DIR/issue-75930-derive-cfg.rs:27:23: 27:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:23: 28:26 (#0), }, Ident { ident: "a", - span: $DIR/issue-75930-derive-cfg.rs:27:27: 27:28 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:27: 28:28 (#0), }, Punct { ch: '=', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:27:29: 27:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:29: 28:30 (#0), }, Literal { kind: Integer, symbol: "25", suffix: None, - span: $DIR/issue-75930-derive-cfg.rs:27:31: 27:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:31: 28:33 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:27:33: 27:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:28:33: 28:34 (#0), }, Ident { ident: "match", - span: $DIR/issue-75930-derive-cfg.rs:28:9: 28:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:29:9: 29:14 (#0), }, Ident { ident: "true", - span: $DIR/issue-75930-derive-cfg.rs:28:15: 28:19 (#0), + span: $DIR/issue-75930-derive-cfg.rs:29:15: 29:19 (#0), }, Group { delimiter: Brace, @@ -460,194 +460,194 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:29:13: 29:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:13: 30:14 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:29:15: 29:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:15: 30:18 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:29:19: 29:24 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:19: 30:24 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:29:18: 29:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:18: 30:25 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:29:14: 29:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:14: 30:26 (#0), }, Ident { ident: "true", - span: $DIR/issue-75930-derive-cfg.rs:29:27: 29:31 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:27: 30:31 (#0), }, Punct { ch: '=', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:29:32: 29:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:32: 30:34 (#0), }, Punct { ch: '>', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:29:32: 29:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:32: 30:34 (#0), }, Group { delimiter: Brace, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:29:35: 29:37 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:35: 30:37 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:29:37: 29:38 (#0), + span: $DIR/issue-75930-derive-cfg.rs:30:37: 30:38 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:30:13: 30:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:13: 31:14 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg_attr", - span: $DIR/issue-75930-derive-cfg.rs:30:15: 30:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:15: 31:23 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:30:24: 30:27 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:24: 31:27 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:30:28: 30:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:28: 31:33 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:30:27: 30:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:27: 31:34 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:30:34: 30:35 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:34: 31:35 (#0), }, Ident { ident: "allow", - span: $DIR/issue-75930-derive-cfg.rs:30:36: 30:41 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:36: 31:41 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "warnings", - span: $DIR/issue-75930-derive-cfg.rs:30:42: 30:50 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:42: 31:50 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:30:41: 30:51 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:41: 31:51 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:30:23: 30:52 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:23: 31:52 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:30:14: 30:53 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:14: 31:53 (#0), }, Ident { ident: "false", - span: $DIR/issue-75930-derive-cfg.rs:30:54: 30:59 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:54: 31:59 (#0), }, Punct { ch: '=', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:30:60: 30:62 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:60: 31:62 (#0), }, Punct { ch: '>', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:30:60: 30:62 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:60: 31:62 (#0), }, Group { delimiter: Brace, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:30:63: 30:65 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:63: 31:65 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:30:65: 30:66 (#0), + span: $DIR/issue-75930-derive-cfg.rs:31:65: 31:66 (#0), }, Ident { ident: "_", - span: $DIR/issue-75930-derive-cfg.rs:31:13: 31:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:32:13: 32:14 (#0), }, Punct { ch: '=', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:31:15: 31:17 (#0), + span: $DIR/issue-75930-derive-cfg.rs:32:15: 32:17 (#0), }, Punct { ch: '>', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:31:15: 31:17 (#0), + span: $DIR/issue-75930-derive-cfg.rs:32:15: 32:17 (#0), }, Group { delimiter: Brace, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:31:18: 31:20 (#0), + span: $DIR/issue-75930-derive-cfg.rs:32:18: 32:20 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:28:20: 32:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:29:20: 33:10 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:32:10: 32:11 (#0), + span: $DIR/issue-75930-derive-cfg.rs:33:10: 33:11 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:34:9: 34:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:35:9: 35:10 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:34:11: 34:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:35:11: 35:23 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "should_be_removed", - span: $DIR/issue-75930-derive-cfg.rs:34:24: 34:41 (#0), + span: $DIR/issue-75930-derive-cfg.rs:35:24: 35:41 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:34:23: 34:42 (#0), + span: $DIR/issue-75930-derive-cfg.rs:35:23: 35:42 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:34:10: 34:43 (#0), + span: $DIR/issue-75930-derive-cfg.rs:35:10: 35:43 (#0), }, Ident { ident: "fn", - span: $DIR/issue-75930-derive-cfg.rs:35:9: 35:11 (#0), + span: $DIR/issue-75930-derive-cfg.rs:36:9: 36:11 (#0), }, Ident { ident: "removed_fn", - span: $DIR/issue-75930-derive-cfg.rs:35:12: 35:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:36:12: 36:22 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:35:22: 35:24 (#0), + span: $DIR/issue-75930-derive-cfg.rs:36:22: 36:24 (#0), }, Group { delimiter: Brace, @@ -655,108 +655,108 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:36:13: 36:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:37:13: 37:14 (#0), }, Punct { ch: '!', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:36:14: 36:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:37:14: 37:15 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:36:16: 36:19 (#0), + span: $DIR/issue-75930-derive-cfg.rs:37:16: 37:19 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:36:20: 36:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:37:20: 37:25 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:36:19: 36:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:37:19: 37:26 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:36:15: 36:27 (#0), + span: $DIR/issue-75930-derive-cfg.rs:37:15: 37:27 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:35:25: 37:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:36:25: 38:10 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:39:9: 39:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:9: 40:10 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:39:11: 39:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:11: 40:23 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "c", - span: $DIR/issue-75930-derive-cfg.rs:39:24: 39:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:24: 40:25 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:39:23: 39:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:23: 40:26 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:39:10: 39:27 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:10: 40:27 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:39:28: 39:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:28: 40:29 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:39:30: 39:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:30: 40:33 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:39:34: 39:37 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:34: 40:37 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:39:38: 39:43 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:38: 40:43 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:39:37: 39:44 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:37: 40:44 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:39:33: 39:45 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:33: 40:45 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:39:29: 39:46 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:29: 40:46 (#0), }, Ident { ident: "fn", - span: $DIR/issue-75930-derive-cfg.rs:39:47: 39:49 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:47: 40:49 (#0), }, Ident { ident: "kept_fn", - span: $DIR/issue-75930-derive-cfg.rs:39:50: 39:57 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:50: 40:57 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:39:57: 39:59 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:57: 40:59 (#0), }, Group { delimiter: Brace, @@ -764,82 +764,82 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:40:13: 40:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:13: 41:14 (#0), }, Punct { ch: '!', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:40:14: 40:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:14: 41:15 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:40:16: 40:19 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:16: 41:19 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:40:20: 40:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:20: 41:23 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:40:24: 40:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:24: 41:29 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:40:23: 40:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:23: 41:30 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:40:19: 40:31 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:19: 41:31 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:40:15: 40:32 (#0), + span: $DIR/issue-75930-derive-cfg.rs:41:15: 41:32 (#0), }, Ident { ident: "let", - span: $DIR/issue-75930-derive-cfg.rs:41:13: 41:16 (#0), + span: $DIR/issue-75930-derive-cfg.rs:42:13: 42:16 (#0), }, Ident { ident: "my_val", - span: $DIR/issue-75930-derive-cfg.rs:41:17: 41:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:42:17: 42:23 (#0), }, Punct { ch: '=', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:41:24: 41:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:42:24: 42:25 (#0), }, Ident { ident: "true", - span: $DIR/issue-75930-derive-cfg.rs:41:26: 41:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:42:26: 42:30 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:41:30: 41:31 (#0), + span: $DIR/issue-75930-derive-cfg.rs:42:30: 42:31 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:39:60: 42:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:40:60: 43:10 (#0), }, Ident { ident: "enum", - span: $DIR/issue-75930-derive-cfg.rs:44:9: 44:13 (#0), + span: $DIR/issue-75930-derive-cfg.rs:45:9: 45:13 (#0), }, Ident { ident: "TupleEnum", - span: $DIR/issue-75930-derive-cfg.rs:44:14: 44:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:45:14: 45:23 (#0), }, Group { delimiter: Brace, stream: TokenStream [ Ident { ident: "Foo", - span: $DIR/issue-75930-derive-cfg.rs:45:13: 45:16 (#0), + span: $DIR/issue-75930-derive-cfg.rs:46:13: 46:16 (#0), }, Group { delimiter: Parenthesis, @@ -847,166 +847,166 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:46:17: 46:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:47:17: 47:18 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:46:19: 46:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:47:19: 47:22 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:46:23: 46:28 (#0), + span: $DIR/issue-75930-derive-cfg.rs:47:23: 47:28 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:46:22: 46:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:47:22: 47:29 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:46:18: 46:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:47:18: 47:30 (#0), }, Ident { ident: "u8", - span: $DIR/issue-75930-derive-cfg.rs:46:31: 46:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:47:31: 47:33 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:46:33: 46:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:47:33: 47:34 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:47:17: 47:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:48:17: 48:18 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:47:19: 47:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:48:19: 48:22 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:47:23: 47:28 (#0), + span: $DIR/issue-75930-derive-cfg.rs:48:23: 48:28 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:47:22: 47:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:48:22: 48:29 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:47:18: 47:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:48:18: 48:30 (#0), }, Ident { ident: "bool", - span: $DIR/issue-75930-derive-cfg.rs:47:31: 47:35 (#0), + span: $DIR/issue-75930-derive-cfg.rs:48:31: 48:35 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:47:35: 47:36 (#0), + span: $DIR/issue-75930-derive-cfg.rs:48:35: 48:36 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:48:17: 48:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:17: 49:18 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:48:19: 48:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:19: 49:22 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:48:23: 48:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:23: 49:26 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:48:27: 48:32 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:27: 49:32 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:48:26: 48:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:26: 49:33 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:48:22: 48:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:22: 49:34 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:48:18: 48:35 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:18: 49:35 (#0), }, Ident { ident: "i32", - span: $DIR/issue-75930-derive-cfg.rs:48:36: 48:39 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:36: 49:39 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:48:39: 48:40 (#0), + span: $DIR/issue-75930-derive-cfg.rs:49:39: 49:40 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:49:17: 49:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:17: 50:18 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:49:19: 49:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:19: 50:22 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:49:23: 49:28 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:23: 50:28 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:49:22: 49:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:22: 50:29 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:49:18: 49:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:18: 50:30 (#0), }, Ident { ident: "String", - span: $DIR/issue-75930-derive-cfg.rs:49:31: 49:37 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:31: 50:37 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:49:37: 49:38 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:37: 50:38 (#0), }, Ident { ident: "u8", - span: $DIR/issue-75930-derive-cfg.rs:49:39: 49:41 (#0), + span: $DIR/issue-75930-derive-cfg.rs:50:39: 50:41 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:45:16: 50:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:46:16: 51:14 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:44:24: 51:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:45:24: 52:10 (#0), }, Ident { ident: "struct", - span: $DIR/issue-75930-derive-cfg.rs:53:9: 53:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:54:9: 54:15 (#0), }, Ident { ident: "TupleStruct", - span: $DIR/issue-75930-derive-cfg.rs:53:16: 53:27 (#0), + span: $DIR/issue-75930-derive-cfg.rs:54:16: 54:27 (#0), }, Group { delimiter: Parenthesis, @@ -1014,184 +1014,184 @@ PRINT-ATTR INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:54:13: 54:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:55:13: 55:14 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:54:15: 54:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:55:15: 55:18 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:54:19: 54:24 (#0), + span: $DIR/issue-75930-derive-cfg.rs:55:19: 55:24 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:54:18: 54:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:55:18: 55:25 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:54:14: 54:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:55:14: 55:26 (#0), }, Ident { ident: "String", - span: $DIR/issue-75930-derive-cfg.rs:54:27: 54:33 (#0), + span: $DIR/issue-75930-derive-cfg.rs:55:27: 55:33 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:54:33: 54:34 (#0), + span: $DIR/issue-75930-derive-cfg.rs:55:33: 55:34 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:55:13: 55:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:13: 56:14 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:55:15: 55:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:15: 56:18 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:55:19: 55:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:19: 56:22 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:55:23: 55:28 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:23: 56:28 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:55:22: 55:29 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:22: 56:29 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:55:18: 55:30 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:18: 56:30 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:55:14: 55:31 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:14: 56:31 (#0), }, Ident { ident: "i32", - span: $DIR/issue-75930-derive-cfg.rs:55:32: 55:35 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:32: 56:35 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:55:35: 55:36 (#0), + span: $DIR/issue-75930-derive-cfg.rs:56:35: 56:36 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:56:13: 56:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:57:13: 57:14 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:56:15: 56:18 (#0), + span: $DIR/issue-75930-derive-cfg.rs:57:15: 57:18 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:56:19: 56:24 (#0), + span: $DIR/issue-75930-derive-cfg.rs:57:19: 57:24 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:56:18: 56:25 (#0), + span: $DIR/issue-75930-derive-cfg.rs:57:18: 57:25 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:56:14: 56:26 (#0), + span: $DIR/issue-75930-derive-cfg.rs:57:14: 57:26 (#0), }, Ident { ident: "bool", - span: $DIR/issue-75930-derive-cfg.rs:56:27: 56:31 (#0), + span: $DIR/issue-75930-derive-cfg.rs:57:27: 57:31 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:56:31: 56:32 (#0), + span: $DIR/issue-75930-derive-cfg.rs:57:31: 57:32 (#0), }, Ident { ident: "u8", - span: $DIR/issue-75930-derive-cfg.rs:57:13: 57:15 (#0), + span: $DIR/issue-75930-derive-cfg.rs:58:13: 58:15 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:53:27: 58:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:54:27: 59:10 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:58:10: 58:11 (#0), + span: $DIR/issue-75930-derive-cfg.rs:59:10: 59:11 (#0), }, Literal { kind: Integer, symbol: "0", suffix: None, - span: $DIR/issue-75930-derive-cfg.rs:60:9: 60:10 (#0), + span: $DIR/issue-75930-derive-cfg.rs:61:9: 61:10 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:24:17: 61:6 (#0), + span: $DIR/issue-75930-derive-cfg.rs:25:17: 62:6 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:24:12: 61:7 (#0), + span: $DIR/issue-75930-derive-cfg.rs:25:12: 62:7 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:61:7: 61:8 (#0), + span: $DIR/issue-75930-derive-cfg.rs:62:7: 62:8 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:62:5: 62:6 (#0), + span: $DIR/issue-75930-derive-cfg.rs:63:5: 63:6 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:62:7: 62:19 (#0), + span: $DIR/issue-75930-derive-cfg.rs:63:7: 63:19 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "d", - span: $DIR/issue-75930-derive-cfg.rs:62:20: 62:21 (#0), + span: $DIR/issue-75930-derive-cfg.rs:63:20: 63:21 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:62:19: 62:22 (#0), + span: $DIR/issue-75930-derive-cfg.rs:63:19: 63:22 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:62:6: 62:23 (#0), + span: $DIR/issue-75930-derive-cfg.rs:63:6: 63:23 (#0), }, Ident { ident: "fourth", - span: $DIR/issue-75930-derive-cfg.rs:63:5: 63:11 (#0), + span: $DIR/issue-75930-derive-cfg.rs:64:5: 64:11 (#0), }, Punct { ch: ':', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:63:11: 63:12 (#0), + span: $DIR/issue-75930-derive-cfg.rs:64:11: 64:12 (#0), }, Ident { ident: "B", - span: $DIR/issue-75930-derive-cfg.rs:63:13: 63:14 (#0), + span: $DIR/issue-75930-derive-cfg.rs:64:13: 64:14 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:32: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:32: 65:2 (#0), }, ] PRINT-DERIVE INPUT (DISPLAY): #[allow(dead_code)] #[print_helper(b)] #[print_helper(a)] struct Foo < B > @@ -1211,141 +1211,141 @@ PRINT-DERIVE INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "allow", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "dead_code", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "b", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "a", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "struct", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "Foo", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '<', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "B", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '>', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Brace, stream: TokenStream [ Ident { ident: "second", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ':', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "bool", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "third", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ':', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "u8", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Brace, @@ -1353,58 +1353,58 @@ PRINT-DERIVE INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "struct", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "Inner", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "match", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "true", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Brace, @@ -1412,146 +1412,146 @@ PRINT-DERIVE INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "allow", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "warnings", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "false", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '=', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '>', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Brace, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "_", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '=', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '>', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Brace, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "c", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "fn", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "kept_fn", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Brace, @@ -1559,82 +1559,82 @@ PRINT-DERIVE INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Joint, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '!', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "let", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "my_val", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '=', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "true", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "enum", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "TupleEnum", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Brace, stream: TokenStream [ Ident { ident: "Foo", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, @@ -1642,69 +1642,69 @@ PRINT-DERIVE INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "i32", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "u8", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "struct", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "TupleStruct", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, @@ -1712,120 +1712,120 @@ PRINT-DERIVE INPUT (DEBUG): TokenStream [ Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "cfg", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "not", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "FALSE", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "i32", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "u8", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ';', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Literal { kind: Integer, symbol: "0", suffix: None, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: '#', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Bracket, stream: TokenStream [ Ident { ident: "print_helper", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [ Ident { ident: "d", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "fourth", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ':', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Ident { ident: "B", - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, Punct { ch: ',', spacing: Alone, - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ], - span: $DIR/issue-75930-derive-cfg.rs:21:1: 64:2 (#0), + span: $DIR/issue-75930-derive-cfg.rs:22:1: 65:2 (#0), }, ] diff --git a/src/test/ui/proc-macro/proc-macro-attributes.rs b/src/test/ui/proc-macro/proc-macro-attributes.rs index 6401522bdf8..8d96381b9bd 100644 --- a/src/test/ui/proc-macro/proc-macro-attributes.rs +++ b/src/test/ui/proc-macro/proc-macro-attributes.rs @@ -4,10 +4,18 @@ extern crate derive_b; #[B] //~ ERROR `B` is ambiguous + //~| WARN derive helper attribute is used before it is introduced + //~| WARN this was previously accepted #[C] //~ ERROR cannot find attribute `C` in this scope #[B(D)] //~ ERROR `B` is ambiguous + //~| WARN derive helper attribute is used before it is introduced + //~| WARN this was previously accepted #[B(E = "foo")] //~ ERROR `B` is ambiguous + //~| WARN derive helper attribute is used before it is introduced + //~| WARN this was previously accepted #[B(arbitrary tokens)] //~ ERROR `B` is ambiguous + //~| WARN derive helper attribute is used before it is introduced + //~| WARN this was previously accepted #[derive(B)] struct B; diff --git a/src/test/ui/proc-macro/proc-macro-attributes.stderr b/src/test/ui/proc-macro/proc-macro-attributes.stderr index 3ac93a74852..1ba04258df0 100644 --- a/src/test/ui/proc-macro/proc-macro-attributes.stderr +++ b/src/test/ui/proc-macro/proc-macro-attributes.stderr @@ -1,5 +1,5 @@ error: cannot find attribute `C` in this scope - --> $DIR/proc-macro-attributes.rs:7:3 + --> $DIR/proc-macro-attributes.rs:9:3 | LL | #[C] | ^ help: a derive helper attribute with a similar name exists: `B` @@ -11,7 +11,7 @@ LL | #[B] | ^ ambiguous name | note: `B` could refer to the derive helper attribute defined here - --> $DIR/proc-macro-attributes.rs:11:10 + --> $DIR/proc-macro-attributes.rs:19:10 | LL | #[derive(B)] | ^ @@ -22,13 +22,13 @@ LL | #[macro_use] | ^^^^^^^^^^^^ error[E0659]: `B` is ambiguous (derive helper attribute vs any other name) - --> $DIR/proc-macro-attributes.rs:8:3 + --> $DIR/proc-macro-attributes.rs:10:3 | LL | #[B(D)] | ^ ambiguous name | note: `B` could refer to the derive helper attribute defined here - --> $DIR/proc-macro-attributes.rs:11:10 + --> $DIR/proc-macro-attributes.rs:19:10 | LL | #[derive(B)] | ^ @@ -39,13 +39,13 @@ LL | #[macro_use] | ^^^^^^^^^^^^ error[E0659]: `B` is ambiguous (derive helper attribute vs any other name) - --> $DIR/proc-macro-attributes.rs:9:3 + --> $DIR/proc-macro-attributes.rs:13:3 | LL | #[B(E = "foo")] | ^ ambiguous name | note: `B` could refer to the derive helper attribute defined here - --> $DIR/proc-macro-attributes.rs:11:10 + --> $DIR/proc-macro-attributes.rs:19:10 | LL | #[derive(B)] | ^ @@ -56,13 +56,13 @@ LL | #[macro_use] | ^^^^^^^^^^^^ error[E0659]: `B` is ambiguous (derive helper attribute vs any other name) - --> $DIR/proc-macro-attributes.rs:10:3 + --> $DIR/proc-macro-attributes.rs:16:3 | LL | #[B(arbitrary tokens)] | ^ ambiguous name | note: `B` could refer to the derive helper attribute defined here - --> $DIR/proc-macro-attributes.rs:11:10 + --> $DIR/proc-macro-attributes.rs:19:10 | LL | #[derive(B)] | ^ @@ -72,6 +72,55 @@ note: `B` could also refer to the derive macro imported here LL | #[macro_use] | ^^^^^^^^^^^^ -error: aborting due to 5 previous errors +warning: derive helper attribute is used before it is introduced + --> $DIR/proc-macro-attributes.rs:6:3 + | +LL | #[B] + | ^ +... +LL | #[derive(B)] + | - the attribute is introduced here + | + = note: `#[warn(legacy_derive_helpers)]` 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 #79202 <https://github.com/rust-lang/rust/issues/79202> + +warning: derive helper attribute is used before it is introduced + --> $DIR/proc-macro-attributes.rs:10:3 + | +LL | #[B(D)] + | ^ +... +LL | #[derive(B)] + | - the attribute is introduced here + | + = 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 #79202 <https://github.com/rust-lang/rust/issues/79202> + +warning: derive helper attribute is used before it is introduced + --> $DIR/proc-macro-attributes.rs:13:3 + | +LL | #[B(E = "foo")] + | ^ +... +LL | #[derive(B)] + | - the attribute is introduced here + | + = 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 #79202 <https://github.com/rust-lang/rust/issues/79202> + +warning: derive helper attribute is used before it is introduced + --> $DIR/proc-macro-attributes.rs:16:3 + | +LL | #[B(arbitrary tokens)] + | ^ +... +LL | #[derive(B)] + | - the attribute is introduced here + | + = 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 #79202 <https://github.com/rust-lang/rust/issues/79202> + +error: aborting due to 5 previous errors; 4 warnings emitted For more information about this error, try `rustc --explain E0659`. diff --git a/src/test/ui/proc-macro/reserved-macro-names.rs b/src/test/ui/proc-macro/reserved-macro-names.rs index 9f56eccb7a6..c5e71a87dfb 100644 --- a/src/test/ui/proc-macro/reserved-macro-names.rs +++ b/src/test/ui/proc-macro/reserved-macro-names.rs @@ -17,9 +17,3 @@ pub fn cfg_attr(_: TokenStream, input: TokenStream) -> TokenStream { //~^ ERROR name `cfg_attr` is reserved in attribute namespace input } - -#[proc_macro_attribute] -pub fn derive(_: TokenStream, input: TokenStream) -> TokenStream { - //~^ ERROR name `derive` is reserved in attribute namespace - input -} diff --git a/src/test/ui/proc-macro/reserved-macro-names.stderr b/src/test/ui/proc-macro/reserved-macro-names.stderr index f871e43ce51..39bdd03be86 100644 --- a/src/test/ui/proc-macro/reserved-macro-names.stderr +++ b/src/test/ui/proc-macro/reserved-macro-names.stderr @@ -10,11 +10,5 @@ error: name `cfg_attr` is reserved in attribute namespace LL | pub fn cfg_attr(_: TokenStream, input: TokenStream) -> TokenStream { | ^^^^^^^^ -error: name `derive` is reserved in attribute namespace - --> $DIR/reserved-macro-names.rs:22:8 - | -LL | pub fn derive(_: TokenStream, input: TokenStream) -> TokenStream { - | ^^^^^^ - -error: aborting due to 3 previous errors +error: aborting due to 2 previous errors diff --git a/src/test/ui/recursion/recursive-types-are-not-uninhabited.stderr b/src/test/ui/recursion/recursive-types-are-not-uninhabited.stderr index c6f500ec8cc..dfb69a3cc1b 100644 --- a/src/test/ui/recursion/recursive-types-are-not-uninhabited.stderr +++ b/src/test/ui/recursion/recursive-types-are-not-uninhabited.stderr @@ -11,7 +11,7 @@ LL | Err(#[stable(feature = "rust1", since = "1.0.0")] E), | = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html - = note: the matched value is of type `std::result::Result<u32, &R>` + = note: the matched value is of type `Result<u32, &R>` help: you might want to use `if let` to ignore the variant that isn't matched | LL | if let Ok(x) = res { /* */ } diff --git a/src/test/ui/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr b/src/test/ui/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr index d015b72c5cf..45806201861 100644 --- a/src/test/ui/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr +++ b/src/test/ui/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr @@ -1,4 +1,4 @@ -error[E0277]: `main` has invalid return type `std::result::Result<f32, ParseFloatError>` +error[E0277]: `main` has invalid return type `Result<f32, ParseFloatError>` --> $DIR/termination-trait-test-wrong-type.rs:6:1 | LL | / fn can_parse_zero_as_f32() -> Result<f32, ParseFloatError> { @@ -11,7 +11,7 @@ LL | | } LL | pub fn assert_test_result<T: Termination>(result: T) { | ----------- required by this bound in `assert_test_result` | - = help: the trait `Termination` is not implemented for `std::result::Result<f32, ParseFloatError>` + = help: the trait `Termination` is not implemented for `Result<f32, ParseFloatError>` = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error diff --git a/src/test/ui/rfc-2294-if-let-guard/typeck.stderr b/src/test/ui/rfc-2294-if-let-guard/typeck.stderr index 7ce93fe7348..6407128d8d8 100644 --- a/src/test/ui/rfc-2294-if-let-guard/typeck.stderr +++ b/src/test/ui/rfc-2294-if-let-guard/typeck.stderr @@ -2,10 +2,10 @@ error[E0308]: mismatched types --> $DIR/typeck.rs:10:22 | LL | Ok(x) if let Err(_) = x => {}, - | ^^^^^^ expected enum `Option`, found enum `std::result::Result` + | ^^^^^^ expected enum `Option`, found enum `Result` | = note: expected enum `Option<bool>` - found enum `std::result::Result<_, _>` + found enum `Result<_, _>` error[E0308]: mismatched types --> $DIR/typeck.rs:12:22 diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.rs b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.rs index 5929d05f4de..493cd7a477c 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.rs +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.rs @@ -9,10 +9,6 @@ struct i32x2(i32, i32); #[repr(simd)] #[derive(Copy, Clone)] #[allow(non_camel_case_types)] -struct i32x3(i32, i32, i32); -#[repr(simd)] -#[derive(Copy, Clone)] -#[allow(non_camel_case_types)] struct i32x4(i32, i32, i32, i32); #[repr(simd)] #[derive(Copy, Clone)] @@ -27,10 +23,6 @@ struct f32x2(f32, f32); #[repr(simd)] #[derive(Copy, Clone)] #[allow(non_camel_case_types)] -struct f32x3(f32, f32, f32); -#[repr(simd)] -#[derive(Copy, Clone)] -#[allow(non_camel_case_types)] struct f32x4(f32, f32, f32, f32); #[repr(simd)] #[derive(Copy, Clone)] @@ -43,7 +35,6 @@ extern "platform-intrinsic" { fn simd_extract<T, E>(x: T, idx: u32) -> E; fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U; - fn simd_shuffle3<T, U>(x: T, y: T, idx: [u32; 3]) -> U; fn simd_shuffle4<T, U>(x: T, y: T, idx: [u32; 4]) -> U; fn simd_shuffle8<T, U>(x: T, y: T, idx: [u32; 8]) -> U; } @@ -61,8 +52,6 @@ fn main() { simd_shuffle2::<i32, i32>(0, 0, [0; 2]); //~^ ERROR expected SIMD input type, found non-SIMD `i32` - simd_shuffle3::<i32, i32>(0, 0, [0; 3]); - //~^ ERROR expected SIMD input type, found non-SIMD `i32` simd_shuffle4::<i32, i32>(0, 0, [0; 4]); //~^ ERROR expected SIMD input type, found non-SIMD `i32` simd_shuffle8::<i32, i32>(0, 0, [0; 8]); @@ -70,8 +59,6 @@ fn main() { simd_shuffle2::<_, f32x2>(x, x, [0; 2]); //~^ ERROR element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32` - simd_shuffle3::<_, f32x3>(x, x, [0; 3]); -//~^ ERROR element type `i32` (element of input `i32x4`), found `f32x3` with element type `f32` simd_shuffle4::<_, f32x4>(x, x, [0; 4]); //~^ ERROR element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32` simd_shuffle8::<_, f32x8>(x, x, [0; 8]); @@ -79,10 +66,8 @@ fn main() { simd_shuffle2::<_, i32x8>(x, x, [0; 2]); //~^ ERROR expected return type of length 2, found `i32x8` with length 8 - simd_shuffle3::<_, i32x4>(x, x, [0; 3]); - //~^ ERROR expected return type of length 3, found `i32x4` with length 4 - simd_shuffle4::<_, i32x3>(x, x, [0; 4]); - //~^ ERROR expected return type of length 4, found `i32x3` with length 3 + simd_shuffle4::<_, i32x8>(x, x, [0; 4]); + //~^ ERROR expected return type of length 4, found `i32x8` with length 8 simd_shuffle8::<_, i32x2>(x, x, [0; 8]); //~^ ERROR expected return type of length 8, found `i32x2` with length 2 } diff --git a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr index 78022c0c8bd..703e64d1ddc 100644 --- a/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr +++ b/src/test/ui/simd-intrinsic/simd-intrinsic-generic-elements.stderr @@ -1,93 +1,75 @@ error[E0511]: invalid monomorphization of `simd_insert` intrinsic: expected SIMD input type, found non-SIMD `i32` - --> $DIR/simd-intrinsic-generic-elements.rs:55:9 + --> $DIR/simd-intrinsic-generic-elements.rs:46:9 | LL | simd_insert(0, 0, 0); | ^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_insert` intrinsic: expected inserted type `i32` (element of input `i32x4`), found `f64` - --> $DIR/simd-intrinsic-generic-elements.rs:57:9 + --> $DIR/simd-intrinsic-generic-elements.rs:48:9 | LL | simd_insert(x, 0, 1.0); | ^^^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_extract` intrinsic: expected return type `i32` (element of input `i32x4`), found `f32` - --> $DIR/simd-intrinsic-generic-elements.rs:59:9 + --> $DIR/simd-intrinsic-generic-elements.rs:50:9 | LL | simd_extract::<_, f32>(x, 0); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_shuffle2` intrinsic: expected SIMD input type, found non-SIMD `i32` - --> $DIR/simd-intrinsic-generic-elements.rs:62:9 + --> $DIR/simd-intrinsic-generic-elements.rs:53:9 | LL | simd_shuffle2::<i32, i32>(0, 0, [0; 2]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0511]: invalid monomorphization of `simd_shuffle3` intrinsic: expected SIMD input type, found non-SIMD `i32` - --> $DIR/simd-intrinsic-generic-elements.rs:64:9 - | -LL | simd_shuffle3::<i32, i32>(0, 0, [0; 3]); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - error[E0511]: invalid monomorphization of `simd_shuffle4` intrinsic: expected SIMD input type, found non-SIMD `i32` - --> $DIR/simd-intrinsic-generic-elements.rs:66:9 + --> $DIR/simd-intrinsic-generic-elements.rs:55:9 | LL | simd_shuffle4::<i32, i32>(0, 0, [0; 4]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_shuffle8` intrinsic: expected SIMD input type, found non-SIMD `i32` - --> $DIR/simd-intrinsic-generic-elements.rs:68:9 + --> $DIR/simd-intrinsic-generic-elements.rs:57:9 | LL | simd_shuffle8::<i32, i32>(0, 0, [0; 8]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_shuffle2` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32` - --> $DIR/simd-intrinsic-generic-elements.rs:71:9 + --> $DIR/simd-intrinsic-generic-elements.rs:60:9 | LL | simd_shuffle2::<_, f32x2>(x, x, [0; 2]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0511]: invalid monomorphization of `simd_shuffle3` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x3` with element type `f32` - --> $DIR/simd-intrinsic-generic-elements.rs:73:9 - | -LL | simd_shuffle3::<_, f32x3>(x, x, [0; 3]); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - error[E0511]: invalid monomorphization of `simd_shuffle4` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32` - --> $DIR/simd-intrinsic-generic-elements.rs:75:9 + --> $DIR/simd-intrinsic-generic-elements.rs:62:9 | LL | simd_shuffle4::<_, f32x4>(x, x, [0; 4]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_shuffle8` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x8` with element type `f32` - --> $DIR/simd-intrinsic-generic-elements.rs:77:9 + --> $DIR/simd-intrinsic-generic-elements.rs:64:9 | LL | simd_shuffle8::<_, f32x8>(x, x, [0; 8]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_shuffle2` intrinsic: expected return type of length 2, found `i32x8` with length 8 - --> $DIR/simd-intrinsic-generic-elements.rs:80:9 + --> $DIR/simd-intrinsic-generic-elements.rs:67:9 | LL | simd_shuffle2::<_, i32x8>(x, x, [0; 2]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0511]: invalid monomorphization of `simd_shuffle3` intrinsic: expected return type of length 3, found `i32x4` with length 4 - --> $DIR/simd-intrinsic-generic-elements.rs:82:9 +error[E0511]: invalid monomorphization of `simd_shuffle4` intrinsic: expected return type of length 4, found `i32x8` with length 8 + --> $DIR/simd-intrinsic-generic-elements.rs:69:9 | -LL | simd_shuffle3::<_, i32x4>(x, x, [0; 3]); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error[E0511]: invalid monomorphization of `simd_shuffle4` intrinsic: expected return type of length 4, found `i32x3` with length 3 - --> $DIR/simd-intrinsic-generic-elements.rs:84:9 - | -LL | simd_shuffle4::<_, i32x3>(x, x, [0; 4]); +LL | simd_shuffle4::<_, i32x8>(x, x, [0; 4]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0511]: invalid monomorphization of `simd_shuffle8` intrinsic: expected return type of length 8, found `i32x2` with length 2 - --> $DIR/simd-intrinsic-generic-elements.rs:86:9 + --> $DIR/simd-intrinsic-generic-elements.rs:71:9 | LL | simd_shuffle8::<_, i32x2>(x, x, [0; 8]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to 15 previous errors +error: aborting due to 12 previous errors For more information about this error, try `rustc --explain E0511`. diff --git a/src/test/ui/simd-type.rs b/src/test/ui/simd-type.rs deleted file mode 100644 index a320df85138..00000000000 --- a/src/test/ui/simd-type.rs +++ /dev/null @@ -1,20 +0,0 @@ -#![feature(repr_simd)] -#![allow(non_camel_case_types)] - -// ignore-tidy-linelength - -#[repr(simd)] -struct empty; //~ ERROR SIMD vector cannot be empty - -#[repr(simd)] -struct i64f64(i64, f64); //~ ERROR SIMD vector should be homogeneous - -struct Foo; - -#[repr(simd)] -struct FooV(Foo, Foo); //~ ERROR SIMD vector element type should be a primitive scalar (integer/float/pointer) type - -#[repr(simd)] -struct FooV2([Foo; 2]); //~ ERROR SIMD vector element type should be a primitive scalar (integer/float/pointer) type - -fn main() {} diff --git a/src/test/ui/issues/issue-17170.rs b/src/test/ui/simd/issue-17170.rs index 8d70dacdc90..49cfbab9a3e 100644 --- a/src/test/ui/issues/issue-17170.rs +++ b/src/test/ui/simd/issue-17170.rs @@ -1,8 +1,8 @@ -// run-pass #![feature(repr_simd)] #[repr(simd)] struct T(f64, f64, f64); +//~^ ERROR SIMD vector length must be a power of two static X: T = T(0.0, 0.0, 0.0); diff --git a/src/test/ui/simd/issue-17170.stderr b/src/test/ui/simd/issue-17170.stderr new file mode 100644 index 00000000000..b35c3c4dc98 --- /dev/null +++ b/src/test/ui/simd/issue-17170.stderr @@ -0,0 +1,11 @@ +error[E0075]: SIMD vector length must be a power of two + --> $DIR/issue-17170.rs:4:1 + | +LL | struct T(f64, f64, f64); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + +error: monomorphising SIMD type `T` of non-power-of-two length + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0075`. diff --git a/src/test/ui/issues/issue-39720.rs b/src/test/ui/simd/issue-39720.rs index 8cf841f9371..7d596926512 100644 --- a/src/test/ui/issues/issue-39720.rs +++ b/src/test/ui/simd/issue-39720.rs @@ -1,4 +1,3 @@ -// run-pass // ignore-emscripten FIXME(#45351) #![feature(repr_simd, platform_intrinsics)] @@ -6,10 +5,12 @@ #[repr(simd)] #[derive(Copy, Clone, Debug)] pub struct Char3(pub i8, pub i8, pub i8); +//~^ ERROR SIMD vector length must be a power of two #[repr(simd)] #[derive(Copy, Clone, Debug)] pub struct Short3(pub i16, pub i16, pub i16); +//~^ ERROR SIMD vector length must be a power of two extern "platform-intrinsic" { fn simd_cast<T, U>(x: T) -> U; diff --git a/src/test/ui/simd/issue-39720.stderr b/src/test/ui/simd/issue-39720.stderr new file mode 100644 index 00000000000..355ceff0050 --- /dev/null +++ b/src/test/ui/simd/issue-39720.stderr @@ -0,0 +1,15 @@ +error[E0075]: SIMD vector length must be a power of two + --> $DIR/issue-39720.rs:7:1 + | +LL | pub struct Char3(pub i8, pub i8, pub i8); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0075]: SIMD vector length must be a power of two + --> $DIR/issue-39720.rs:12:1 + | +LL | pub struct Short3(pub i16, pub i16, pub i16); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0075`. diff --git a/src/test/ui/simd/simd-intrinsic-generic-elements.rs b/src/test/ui/simd/simd-intrinsic-generic-elements.rs index ea3d4b18944..a85ec7c5823 100644 --- a/src/test/ui/simd/simd-intrinsic-generic-elements.rs +++ b/src/test/ui/simd/simd-intrinsic-generic-elements.rs @@ -10,10 +10,6 @@ struct i32x2(i32, i32); #[repr(simd)] #[derive(Copy, Clone, Debug, PartialEq)] #[allow(non_camel_case_types)] -struct i32x3(i32, i32, i32); -#[repr(simd)] -#[derive(Copy, Clone, Debug, PartialEq)] -#[allow(non_camel_case_types)] struct i32x4(i32, i32, i32, i32); #[repr(simd)] #[derive(Copy, Clone, Debug, PartialEq)] @@ -26,7 +22,6 @@ extern "platform-intrinsic" { fn simd_extract<T, E>(x: T, idx: u32) -> E; fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U; - fn simd_shuffle3<T, U>(x: T, y: T, idx: [u32; 3]) -> U; fn simd_shuffle4<T, U>(x: T, y: T, idx: [u32; 4]) -> U; fn simd_shuffle8<T, U>(x: T, y: T, idx: [u32; 8]) -> U; } @@ -45,17 +40,12 @@ macro_rules! all_eq { fn main() { let x2 = i32x2(20, 21); - let x3 = i32x3(30, 31, 32); let x4 = i32x4(40, 41, 42, 43); let x8 = i32x8(80, 81, 82, 83, 84, 85, 86, 87); unsafe { all_eq!(simd_insert(x2, 0, 100), i32x2(100, 21)); all_eq!(simd_insert(x2, 1, 100), i32x2(20, 100)); - all_eq!(simd_insert(x3, 0, 100), i32x3(100, 31, 32)); - all_eq!(simd_insert(x3, 1, 100), i32x3(30, 100, 32)); - all_eq!(simd_insert(x3, 2, 100), i32x3(30, 31, 100)); - all_eq!(simd_insert(x4, 0, 100), i32x4(100, 41, 42, 43)); all_eq!(simd_insert(x4, 1, 100), i32x4(40, 100, 42, 43)); all_eq!(simd_insert(x4, 2, 100), i32x4(40, 41, 100, 43)); @@ -73,10 +63,6 @@ fn main() { all_eq!(simd_extract(x2, 0), 20); all_eq!(simd_extract(x2, 1), 21); - all_eq!(simd_extract(x3, 0), 30); - all_eq!(simd_extract(x3, 1), 31); - all_eq!(simd_extract(x3, 2), 32); - all_eq!(simd_extract(x4, 0), 40); all_eq!(simd_extract(x4, 1), 41); all_eq!(simd_extract(x4, 2), 42); @@ -93,30 +79,20 @@ fn main() { } let y2 = i32x2(120, 121); - let y3 = i32x3(130, 131, 132); let y4 = i32x4(140, 141, 142, 143); let y8 = i32x8(180, 181, 182, 183, 184, 185, 186, 187); unsafe { all_eq!(simd_shuffle2(x2, y2, [3, 0]), i32x2(121, 20)); - all_eq!(simd_shuffle3(x2, y2, [3, 0, 1]), i32x3(121, 20, 21)); all_eq!(simd_shuffle4(x2, y2, [3, 0, 1, 2]), i32x4(121, 20, 21, 120)); all_eq!(simd_shuffle8(x2, y2, [3, 0, 1, 2, 1, 2, 3, 0]), i32x8(121, 20, 21, 120, 21, 120, 121, 20)); - all_eq!(simd_shuffle2(x3, y3, [4, 2]), i32x2(131, 32)); - all_eq!(simd_shuffle3(x3, y3, [4, 2, 3]), i32x3(131, 32, 130)); - all_eq!(simd_shuffle4(x3, y3, [4, 2, 3, 0]), i32x4(131, 32, 130, 30)); - all_eq!(simd_shuffle8(x3, y3, [4, 2, 3, 0, 1, 5, 5, 1]), - i32x8(131, 32, 130, 30, 31, 132, 132, 31)); - all_eq!(simd_shuffle2(x4, y4, [7, 2]), i32x2(143, 42)); - all_eq!(simd_shuffle3(x4, y4, [7, 2, 5]), i32x3(143, 42, 141)); all_eq!(simd_shuffle4(x4, y4, [7, 2, 5, 0]), i32x4(143, 42, 141, 40)); all_eq!(simd_shuffle8(x4, y4, [7, 2, 5, 0, 3, 6, 4, 1]), i32x8(143, 42, 141, 40, 43, 142, 140, 41)); all_eq!(simd_shuffle2(x8, y8, [11, 5]), i32x2(183, 85)); - all_eq!(simd_shuffle3(x8, y8, [11, 5, 15]), i32x3(183, 85, 187)); all_eq!(simd_shuffle4(x8, y8, [11, 5, 15, 0]), i32x4(183, 85, 187, 80)); all_eq!(simd_shuffle8(x8, y8, [11, 5, 15, 0, 3, 8, 12, 1]), i32x8(183, 85, 187, 80, 83, 180, 184, 81)); diff --git a/src/test/ui/simd/simd-size-align.rs b/src/test/ui/simd/simd-size-align.rs index 556013788c3..0afa4947225 100644 --- a/src/test/ui/simd/simd-size-align.rs +++ b/src/test/ui/simd/simd-size-align.rs @@ -10,87 +10,44 @@ use std::mem; /// `T` should satisfy `size_of T (mod min_align_of T) === 0` to be stored at `Vec<T>` properly /// Please consult the issue #20460 fn check<T>() { - assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0) + assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0); + assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0); + assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0); } -fn main() { - check::<u8x2>(); - check::<u8x3>(); - check::<u8x4>(); - check::<u8x5>(); - check::<u8x6>(); - check::<u8x7>(); - check::<u8x8>(); +#[repr(simd)] +struct U8<const N: usize>([u8; N]); - check::<i16x2>(); - check::<i16x3>(); - check::<i16x4>(); - check::<i16x5>(); - check::<i16x6>(); - check::<i16x7>(); - check::<i16x8>(); +#[repr(simd)] +struct I16<const N: usize>([i16; N]); - check::<f32x2>(); - check::<f32x3>(); - check::<f32x4>(); - check::<f32x5>(); - check::<f32x6>(); - check::<f32x7>(); - check::<f32x8>(); +#[repr(simd)] +struct F32<const N: usize>([f32; N]); - check::<usizex2>(); - check::<usizex3>(); - check::<usizex4>(); - check::<usizex5>(); - check::<usizex6>(); - check::<usizex7>(); - check::<usizex8>(); +#[repr(simd)] +struct Usize<const N: usize>([usize; N]); - check::<isizex2>(); - check::<isizex3>(); - check::<isizex4>(); - check::<isizex5>(); - check::<isizex6>(); - check::<isizex7>(); - check::<isizex8>(); -} +#[repr(simd)] +struct Isize<const N: usize>([isize; N]); -#[repr(simd)] struct u8x2(u8, u8); -#[repr(simd)] struct u8x3(u8, u8, u8); -#[repr(simd)] struct u8x4(u8, u8, u8, u8); -#[repr(simd)] struct u8x5(u8, u8, u8, u8, u8); -#[repr(simd)] struct u8x6(u8, u8, u8, u8, u8, u8); -#[repr(simd)] struct u8x7(u8, u8, u8, u8, u8, u8, u8); -#[repr(simd)] struct u8x8(u8, u8, u8, u8, u8, u8, u8, u8); +fn main() { + check::<U8<2>>(); + check::<U8<4>>(); + check::<U8<8>>(); -#[repr(simd)] struct i16x2(i16, i16); -#[repr(simd)] struct i16x3(i16, i16, i16); -#[repr(simd)] struct i16x4(i16, i16, i16, i16); -#[repr(simd)] struct i16x5(i16, i16, i16, i16, i16); -#[repr(simd)] struct i16x6(i16, i16, i16, i16, i16, i16); -#[repr(simd)] struct i16x7(i16, i16, i16, i16, i16, i16, i16); -#[repr(simd)] struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16); + check::<I16<2>>(); + check::<I16<4>>(); + check::<I16<8>>(); -#[repr(simd)] struct f32x2(f32, f32); -#[repr(simd)] struct f32x3(f32, f32, f32); -#[repr(simd)] struct f32x4(f32, f32, f32, f32); -#[repr(simd)] struct f32x5(f32, f32, f32, f32, f32); -#[repr(simd)] struct f32x6(f32, f32, f32, f32, f32, f32); -#[repr(simd)] struct f32x7(f32, f32, f32, f32, f32, f32, f32); -#[repr(simd)] struct f32x8(f32, f32, f32, f32, f32, f32, f32, f32); + check::<F32<2>>(); + check::<F32<4>>(); + check::<F32<8>>(); -#[repr(simd)] struct usizex2(usize, usize); -#[repr(simd)] struct usizex3(usize, usize, usize); -#[repr(simd)] struct usizex4(usize, usize, usize, usize); -#[repr(simd)] struct usizex5(usize, usize, usize, usize, usize); -#[repr(simd)] struct usizex6(usize, usize, usize, usize, usize, usize); -#[repr(simd)] struct usizex7(usize, usize, usize, usize, usize, usize, usize); -#[repr(simd)] struct usizex8(usize, usize, usize, usize, usize, usize, usize, usize); + check::<Usize<2>>(); + check::<Usize<4>>(); + check::<Usize<8>>(); -#[repr(simd)] struct isizex2(isize, isize); -#[repr(simd)] struct isizex3(isize, isize, isize); -#[repr(simd)] struct isizex4(isize, isize, isize, isize); -#[repr(simd)] struct isizex5(isize, isize, isize, isize, isize); -#[repr(simd)] struct isizex6(isize, isize, isize, isize, isize, isize); -#[repr(simd)] struct isizex7(isize, isize, isize, isize, isize, isize, isize); -#[repr(simd)] struct isizex8(isize, isize, isize, isize, isize, isize, isize, isize); + check::<Isize<2>>(); + check::<Isize<4>>(); + check::<Isize<8>>(); +} diff --git a/src/test/ui/simd/simd-type-generic-monomorphisation-empty.rs b/src/test/ui/simd/simd-type-generic-monomorphisation-empty.rs new file mode 100644 index 00000000000..0121404c749 --- /dev/null +++ b/src/test/ui/simd/simd-type-generic-monomorphisation-empty.rs @@ -0,0 +1,12 @@ +// build-fail + +#![feature(repr_simd, platform_intrinsics)] + +// error-pattern:monomorphising SIMD type `Simd<0_usize>` of zero length + +#[repr(simd)] +struct Simd<const N: usize>([f32; N]); + +fn main() { + let _ = Simd::<0>([]); +} diff --git a/src/test/ui/simd/simd-type-generic-monomorphisation-empty.stderr b/src/test/ui/simd/simd-type-generic-monomorphisation-empty.stderr new file mode 100644 index 00000000000..00fde199b12 --- /dev/null +++ b/src/test/ui/simd/simd-type-generic-monomorphisation-empty.stderr @@ -0,0 +1,4 @@ +error: monomorphising SIMD type `Simd<0_usize>` of zero length + +error: aborting due to previous error + diff --git a/src/test/ui/simd/simd-type-generic-monomorphisation-oversized.rs b/src/test/ui/simd/simd-type-generic-monomorphisation-oversized.rs new file mode 100644 index 00000000000..bd0d457b35e --- /dev/null +++ b/src/test/ui/simd/simd-type-generic-monomorphisation-oversized.rs @@ -0,0 +1,12 @@ +// build-fail + +#![feature(repr_simd, platform_intrinsics)] + +// error-pattern:monomorphising SIMD type `Simd<65536_usize>` of length greater than 32768 + +#[repr(simd)] +struct Simd<const N: usize>([f32; N]); + +fn main() { + let _ = Simd::<65536>([0.; 65536]); +} diff --git a/src/test/ui/simd/simd-type-generic-monomorphisation-oversized.stderr b/src/test/ui/simd/simd-type-generic-monomorphisation-oversized.stderr new file mode 100644 index 00000000000..f4418350115 --- /dev/null +++ b/src/test/ui/simd/simd-type-generic-monomorphisation-oversized.stderr @@ -0,0 +1,4 @@ +error: monomorphising SIMD type `Simd<65536_usize>` of length greater than 32768 + +error: aborting due to previous error + diff --git a/src/test/ui/simd/simd-type-generic-monomorphisation-power-of-two.rs b/src/test/ui/simd/simd-type-generic-monomorphisation-power-of-two.rs new file mode 100644 index 00000000000..3a0b9e02663 --- /dev/null +++ b/src/test/ui/simd/simd-type-generic-monomorphisation-power-of-two.rs @@ -0,0 +1,12 @@ +// build-fail + +#![feature(repr_simd, platform_intrinsics)] + +// error-pattern:monomorphising SIMD type `Simd<3_usize>` of non-power-of-two length + +#[repr(simd)] +struct Simd<const N: usize>([f32; N]); + +fn main() { + let _ = Simd::<3>([0.; 3]); +} diff --git a/src/test/ui/simd/simd-type-generic-monomorphisation-power-of-two.stderr b/src/test/ui/simd/simd-type-generic-monomorphisation-power-of-two.stderr new file mode 100644 index 00000000000..82cc0d8714a --- /dev/null +++ b/src/test/ui/simd/simd-type-generic-monomorphisation-power-of-two.stderr @@ -0,0 +1,4 @@ +error: monomorphising SIMD type `Simd<3_usize>` of non-power-of-two length + +error: aborting due to previous error + diff --git a/src/test/ui/simd-type-generic-monomorphisation.rs b/src/test/ui/simd/simd-type-generic-monomorphisation.rs index 0275f0ce4c1..0275f0ce4c1 100644 --- a/src/test/ui/simd-type-generic-monomorphisation.rs +++ b/src/test/ui/simd/simd-type-generic-monomorphisation.rs diff --git a/src/test/ui/simd-type-generic-monomorphisation.stderr b/src/test/ui/simd/simd-type-generic-monomorphisation.stderr index 7f23893ac85..7f23893ac85 100644 --- a/src/test/ui/simd-type-generic-monomorphisation.stderr +++ b/src/test/ui/simd/simd-type-generic-monomorphisation.stderr diff --git a/src/test/ui/simd/simd-type.rs b/src/test/ui/simd/simd-type.rs index e7b9bfe32f8..cc7443d0485 100644 --- a/src/test/ui/simd/simd-type.rs +++ b/src/test/ui/simd/simd-type.rs @@ -1,9 +1,33 @@ -// run-pass -#![allow(dead_code)] +#![feature(repr_simd)] +#![allow(non_camel_case_types)] -// pretty-expanded FIXME #23616 +// ignore-tidy-linelength -#![feature(repr_simd)] +#[repr(simd)] +struct empty; //~ ERROR SIMD vector cannot be empty + +#[repr(simd)] +struct empty2([f32; 0]); //~ ERROR SIMD vector cannot be empty + +#[repr(simd)] +struct pow2([f32; 7]); //~ ERROR SIMD vector length must be a power of two + +#[repr(simd)] +struct i64f64(i64, f64); //~ ERROR SIMD vector should be homogeneous + +struct Foo; + +#[repr(simd)] +struct FooV(Foo, Foo); //~ ERROR SIMD vector element type should be a primitive scalar (integer/float/pointer) type + +#[repr(simd)] +struct FooV2([Foo; 2]); //~ ERROR SIMD vector element type should be a primitive scalar (integer/float/pointer) type + +#[repr(simd)] +struct TooBig([f32; 65536]); //~ ERROR SIMD vector cannot have more than 32768 elements + +#[repr(simd)] +struct JustRight([u128; 32768]); #[repr(simd)] struct RGBA { @@ -13,4 +37,4 @@ struct RGBA { a: f32 } -pub fn main() {} +fn main() {} diff --git a/src/test/ui/simd-type.stderr b/src/test/ui/simd/simd-type.stderr index 23004c78591..8b15ef05e03 100644 --- a/src/test/ui/simd-type.stderr +++ b/src/test/ui/simd/simd-type.stderr @@ -4,25 +4,43 @@ error[E0075]: SIMD vector cannot be empty LL | struct empty; | ^^^^^^^^^^^^^ -error[E0076]: SIMD vector should be homogeneous +error[E0075]: SIMD vector cannot be empty --> $DIR/simd-type.rs:10:1 | +LL | struct empty2([f32; 0]); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0075]: SIMD vector length must be a power of two + --> $DIR/simd-type.rs:13:1 + | +LL | struct pow2([f32; 7]); + | ^^^^^^^^^^^^^^^^^^^^^^ + +error[E0076]: SIMD vector should be homogeneous + --> $DIR/simd-type.rs:16:1 + | LL | struct i64f64(i64, f64); | ^^^^^^^^^^^^^^^^^^^^^^^^ SIMD elements must have the same type error[E0077]: SIMD vector element type should be a primitive scalar (integer/float/pointer) type - --> $DIR/simd-type.rs:15:1 + --> $DIR/simd-type.rs:21:1 | LL | struct FooV(Foo, Foo); | ^^^^^^^^^^^^^^^^^^^^^^ error[E0077]: SIMD vector element type should be a primitive scalar (integer/float/pointer) type - --> $DIR/simd-type.rs:18:1 + --> $DIR/simd-type.rs:24:1 | LL | struct FooV2([Foo; 2]); | ^^^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to 4 previous errors +error[E0075]: SIMD vector cannot have more than 32768 elements + --> $DIR/simd-type.rs:27:1 + | +LL | struct TooBig([f32; 65536]); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 7 previous errors Some errors have detailed explanations: E0075, E0076, E0077. For more information about an error, try `rustc --explain E0075`. diff --git a/src/test/ui/span/impl-wrong-item-for-trait.stderr b/src/test/ui/span/impl-wrong-item-for-trait.stderr index 9b0aad28b0a..de200ca0721 100644 --- a/src/test/ui/span/impl-wrong-item-for-trait.stderr +++ b/src/test/ui/span/impl-wrong-item-for-trait.stderr @@ -64,7 +64,7 @@ error[E0046]: not all trait items implemented, missing: `fmt` LL | impl Debug for FooTypeForMethod { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `fmt` in implementation | - = help: implement the missing item: `fn fmt(&self, _: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { todo!() }` + = help: implement the missing item: `fn fmt(&self, _: &mut Formatter<'_>) -> Result<(), std::fmt::Error> { todo!() }` error: aborting due to 8 previous errors diff --git a/src/test/ui/span/issue-43927-non-ADT-derive.rs b/src/test/ui/span/issue-43927-non-ADT-derive.rs index 8f1599a5abc..840c12e16e1 100644 --- a/src/test/ui/span/issue-43927-non-ADT-derive.rs +++ b/src/test/ui/span/issue-43927-non-ADT-derive.rs @@ -1,10 +1,5 @@ -#![allow(dead_code)] - #![derive(Debug, PartialEq, Eq)] // should be an outer attribute! -//~^ ERROR `derive` may only be applied to structs, enums and unions -//~| ERROR cannot determine resolution for the derive macro `Debug` -//~| ERROR cannot determine resolution for the derive macro `PartialEq` -//~| ERROR cannot determine resolution for the derive macro `Eq` +//~^ ERROR cannot determine resolution for the attribute macro `derive` struct DerivedOn; fn main() {} diff --git a/src/test/ui/span/issue-43927-non-ADT-derive.stderr b/src/test/ui/span/issue-43927-non-ADT-derive.stderr index 85beac535c9..9ef81c5150a 100644 --- a/src/test/ui/span/issue-43927-non-ADT-derive.stderr +++ b/src/test/ui/span/issue-43927-non-ADT-derive.stderr @@ -1,33 +1,10 @@ -error[E0774]: `derive` may only be applied to structs, enums and unions - --> $DIR/issue-43927-non-ADT-derive.rs:3:1 +error: cannot determine resolution for the attribute macro `derive` + --> $DIR/issue-43927-non-ADT-derive.rs:1:4 | LL | #![derive(Debug, PartialEq, Eq)] // should be an outer attribute! - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try an outer attribute: `#[derive(Debug, PartialEq, Eq)]` - -error: cannot determine resolution for the derive macro `Debug` - --> $DIR/issue-43927-non-ADT-derive.rs:3:11 - | -LL | #![derive(Debug, PartialEq, Eq)] // should be an outer attribute! - | ^^^^^ - | - = note: import resolution is stuck, try simplifying macro imports - -error: cannot determine resolution for the derive macro `PartialEq` - --> $DIR/issue-43927-non-ADT-derive.rs:3:18 - | -LL | #![derive(Debug, PartialEq, Eq)] // should be an outer attribute! - | ^^^^^^^^^ - | - = note: import resolution is stuck, try simplifying macro imports - -error: cannot determine resolution for the derive macro `Eq` - --> $DIR/issue-43927-non-ADT-derive.rs:3:29 - | -LL | #![derive(Debug, PartialEq, Eq)] // should be an outer attribute! - | ^^ + | ^^^^^^ | = note: import resolution is stuck, try simplifying macro imports -error: aborting due to 4 previous errors +error: aborting due to previous error -For more information about this error, try `rustc --explain E0774`. diff --git a/src/test/ui/span/macro-ty-params.rs b/src/test/ui/span/macro-ty-params.rs index 713b9eb542c..0a93105b664 100644 --- a/src/test/ui/span/macro-ty-params.rs +++ b/src/test/ui/span/macro-ty-params.rs @@ -9,5 +9,5 @@ macro_rules! foo { () => () } fn main() { foo::<T>!(); //~ ERROR generic arguments in macro path foo::<>!(); //~ ERROR generic arguments in macro path - m!(Default<>); //~ ERROR generic arguments in macro path + m!(Default<>); //~ ERROR unexpected generic arguments in path } diff --git a/src/test/ui/span/macro-ty-params.stderr b/src/test/ui/span/macro-ty-params.stderr index 21683b2fb86..138cd2598a1 100644 --- a/src/test/ui/span/macro-ty-params.stderr +++ b/src/test/ui/span/macro-ty-params.stderr @@ -10,7 +10,7 @@ error: generic arguments in macro path LL | foo::<>!(); | ^^ -error: generic arguments in macro path +error: unexpected generic arguments in path --> $DIR/macro-ty-params.rs:12:15 | LL | m!(Default<>); diff --git a/src/test/ui/stability-attribute/stability-attribute-sanity.stderr b/src/test/ui/stability-attribute/stability-attribute-sanity.stderr index ee9a93359f0..151b96b8b5a 100644 --- a/src/test/ui/stability-attribute/stability-attribute-sanity.stderr +++ b/src/test/ui/stability-attribute/stability-attribute-sanity.stderr @@ -116,5 +116,5 @@ LL | #[rustc_deprecated(since = "a", reason = "text")] error: aborting due to 19 previous errors -Some errors have detailed explanations: E0539, E0541, E0546, E0550. +Some errors have detailed explanations: E0539, E0541, E0542, E0546, E0550. For more information about an error, try `rustc --explain E0539`. diff --git a/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr b/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr index 9450612332c..9437fbe61cc 100644 --- a/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr +++ b/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr @@ -13,7 +13,7 @@ help: you could relax the implicit `Sized` bound on `T` if it were used through --> $DIR/adt-param-with-implicit-sized-bound.rs:18:10 | LL | struct X<T>(T); - | ^ - ...if indirection was used here: `Box<T>` + | ^ - ...if indirection were used here: `Box<T>` | | | this could be changed to `T: ?Sized`... @@ -68,7 +68,7 @@ help: you could relax the implicit `Sized` bound on `T` if it were used through LL | struct Struct3<T>{ | ^ this could be changed to `T: ?Sized`... LL | _t: T, - | - ...if indirection was used here: `Box<T>` + | - ...if indirection were used here: `Box<T>` help: consider further restricting `Self` | LL | fn func3() -> Struct3<Self> where Self: Sized; diff --git a/src/test/ui/suggestions/as-ref.stderr b/src/test/ui/suggestions/as-ref.stderr index 4b5a9be7e5b..7e4d7fb3933 100644 --- a/src/test/ui/suggestions/as-ref.stderr +++ b/src/test/ui/suggestions/as-ref.stderr @@ -47,12 +47,12 @@ error[E0308]: mismatched types --> $DIR/as-ref.rs:19:35 | LL | let y: Result<&usize, &usize> = x; - | ---------------------- ^ expected enum `std::result::Result`, found reference + | ---------------------- ^ expected enum `Result`, found reference | | | expected due to this | - = note: expected enum `std::result::Result<&usize, &usize>` - found reference `&std::result::Result<usize, usize>` + = note: expected enum `Result<&usize, &usize>` + found reference `&Result<usize, usize>` help: you can convert from `&Result<T, E>` to `Result<&T, &E>` using `.as_ref()` | LL | let y: Result<&usize, &usize> = x.as_ref(); @@ -62,12 +62,12 @@ error[E0308]: mismatched types --> $DIR/as-ref.rs:23:34 | LL | let y: Result<&usize, usize> = x; - | --------------------- ^ expected enum `std::result::Result`, found reference + | --------------------- ^ expected enum `Result`, found reference | | | expected due to this | - = note: expected enum `std::result::Result<&usize, usize>` - found reference `&std::result::Result<usize, usize>` + = note: expected enum `Result<&usize, usize>` + found reference `&Result<usize, usize>` error: aborting due to 7 previous errors diff --git a/src/test/ui/suggestions/mut-ref-reassignment.stderr b/src/test/ui/suggestions/mut-ref-reassignment.stderr index e31c4dc66c8..327bbee1968 100644 --- a/src/test/ui/suggestions/mut-ref-reassignment.stderr +++ b/src/test/ui/suggestions/mut-ref-reassignment.stderr @@ -17,7 +17,7 @@ error[E0308]: mismatched types LL | opt = None | ^^^^ expected mutable reference, found enum `Option` | - = note: expected mutable reference `&mut std::result::Result<String, ()>` + = note: expected mutable reference `&mut Result<String, ()>` found enum `Option<_>` error[E0308]: mismatched types diff --git a/src/test/ui/suggestions/option-content-move.stderr b/src/test/ui/suggestions/option-content-move.stderr index 0f3dd346e85..c00a0f1700b 100644 --- a/src/test/ui/suggestions/option-content-move.stderr +++ b/src/test/ui/suggestions/option-content-move.stderr @@ -13,7 +13,7 @@ error[E0507]: cannot move out of `selection.1` which is behind a shared referenc LL | if selection.1.unwrap().contains(selection.0) { | ^^^^^^^^^^^ | | - | move occurs because `selection.1` has type `std::result::Result<String, String>`, which does not implement the `Copy` trait + | move occurs because `selection.1` has type `Result<String, String>`, which does not implement the `Copy` trait | help: consider borrowing the `Result`'s content: `selection.1.as_ref()` error: aborting due to 2 previous errors diff --git a/src/test/ui/suggestions/suggest-box.stderr b/src/test/ui/suggestions/suggest-box.stderr index 57c83baf4f8..8107fd86212 100644 --- a/src/test/ui/suggestions/suggest-box.stderr +++ b/src/test/ui/suggestions/suggest-box.stderr @@ -10,7 +10,7 @@ LL | | Ok(()) LL | | }; | |_____^ expected struct `Box`, found closure | - = note: expected struct `Box<dyn Fn() -> std::result::Result<(), ()>>` + = note: expected struct `Box<dyn Fn() -> Result<(), ()>>` found closure `[closure@$DIR/suggest-box.rs:4:47: 7:6]` = note: for more on the distinction between the stack and the heap, read https://doc.rust-lang.org/book/ch15-01-box.html, https://doc.rust-lang.org/rust-by-example/std/box.html, and https://doc.rust-lang.org/std/boxed/index.html help: store this in the heap by calling `Box::new` diff --git a/src/test/ui/test-attrs/test-filter-multiple.rs b/src/test/ui/test-attrs/test-filter-multiple.rs new file mode 100644 index 00000000000..04dd83b7fd0 --- /dev/null +++ b/src/test/ui/test-attrs/test-filter-multiple.rs @@ -0,0 +1,17 @@ +// run-pass +// compile-flags: --test +// run-flags: --test-threads=1 test1 test2 +// check-run-results +// normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME" +// ignore-emscripten no threads support + +#[test] +fn test1() {} + +#[test] +fn test2() {} + +#[test] +fn test3() { + panic!("this should not run"); +} diff --git a/src/test/ui/test-attrs/test-filter-multiple.run.stdout b/src/test/ui/test-attrs/test-filter-multiple.run.stdout new file mode 100644 index 00000000000..1aa684ed507 --- /dev/null +++ b/src/test/ui/test-attrs/test-filter-multiple.run.stdout @@ -0,0 +1,7 @@ + +running 2 tests +test test1 ... ok +test test2 ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in $TIME + diff --git a/src/test/ui/traits/self-without-lifetime-constraint.stderr b/src/test/ui/traits/self-without-lifetime-constraint.stderr index 6c7abe753e2..73b5aec022c 100644 --- a/src/test/ui/traits/self-without-lifetime-constraint.stderr +++ b/src/test/ui/traits/self-without-lifetime-constraint.stderr @@ -2,13 +2,13 @@ error: `impl` item signature doesn't match `trait` item signature --> $DIR/self-without-lifetime-constraint.rs:45:5 | LL | fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self, &Self>; - | -------------------------------------------------------------------- expected `fn(ValueRef<'_>) -> std::result::Result<(&str, &&str), FromSqlError>` + | -------------------------------------------------------------------- expected `fn(ValueRef<'_>) -> Result<(&str, &&str), FromSqlError>` ... LL | fn column_result(value: ValueRef<'_>) -> FromSqlResult<&str, &&str> { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(ValueRef<'_>) -> std::result::Result<(&str, &&str), FromSqlError>` + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(ValueRef<'_>) -> Result<(&str, &&str), FromSqlError>` | - = note: expected `fn(ValueRef<'_>) -> std::result::Result<(&str, &&str), _>` - found `fn(ValueRef<'_>) -> std::result::Result<(&str, &&str), _>` + = note: expected `fn(ValueRef<'_>) -> Result<(&str, &&str), _>` + found `fn(ValueRef<'_>) -> Result<(&str, &&str), _>` help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait` --> $DIR/self-without-lifetime-constraint.rs:41:60 | diff --git a/src/test/ui/treat-err-as-bug/delay_span_bug.rs b/src/test/ui/treat-err-as-bug/delay_span_bug.rs new file mode 100644 index 00000000000..67846336aca --- /dev/null +++ b/src/test/ui/treat-err-as-bug/delay_span_bug.rs @@ -0,0 +1,11 @@ +// compile-flags: -Ztreat-err-as-bug +// failure-status: 101 +// error-pattern: aborting due to `-Z treat-err-as-bug=1` +// error-pattern: [trigger_delay_span_bug] trigger a delay span bug +// normalize-stderr-test "note: .*\n\n" -> "" +// normalize-stderr-test "thread 'rustc' panicked.*\n" -> "" + +#![feature(rustc_attrs)] + +#[rustc_error(delay_span_bug_from_inside_query)] +fn main() {} diff --git a/src/test/ui/treat-err-as-bug/delay_span_bug.stderr b/src/test/ui/treat-err-as-bug/delay_span_bug.stderr new file mode 100644 index 00000000000..ed65b69ebca --- /dev/null +++ b/src/test/ui/treat-err-as-bug/delay_span_bug.stderr @@ -0,0 +1,11 @@ +error: internal compiler error: delayed span bug triggered by #[rustc_error(delay_span_bug_from_inside_query)] + --> $DIR/delay_span_bug.rs:11:1 + | +LL | fn main() {} + | ^^^^^^^^^ + +error: internal compiler error: unexpected panic + +query stack during panic: +#0 [trigger_delay_span_bug] trigger a delay span bug +end of query stack diff --git a/src/test/ui/treat-err-as-bug/err.rs b/src/test/ui/treat-err-as-bug/err.rs new file mode 100644 index 00000000000..5442d858594 --- /dev/null +++ b/src/test/ui/treat-err-as-bug/err.rs @@ -0,0 +1,11 @@ +// compile-flags: -Ztreat-err-as-bug +// failure-status: 101 +// error-pattern: aborting due to `-Z treat-err-as-bug=1` +// error-pattern: [eval_to_allocation_raw] const-evaluating + checking `C` +// normalize-stderr-test "note: .*\n\n" -> "" +// normalize-stderr-test "thread 'rustc' panicked.*\n" -> "" + +#![crate_type = "rlib"] + +pub static C: u32 = 0 - 1; +//~^ ERROR could not evaluate static initializer diff --git a/src/test/ui/treat-err-as-bug/err.stderr b/src/test/ui/treat-err-as-bug/err.stderr new file mode 100644 index 00000000000..61eb85c40a1 --- /dev/null +++ b/src/test/ui/treat-err-as-bug/err.stderr @@ -0,0 +1,12 @@ +error[E0080]: could not evaluate static initializer + --> $DIR/err.rs:10:21 + | +LL | pub static C: u32 = 0 - 1; + | ^^^^^ attempt to compute `0_u32 - 1_u32`, which would overflow + +error: internal compiler error: unexpected panic + +query stack during panic: +#0 [eval_to_allocation_raw] const-evaluating + checking `C` +#1 [eval_to_allocation_raw] const-evaluating + checking `C` +end of query stack diff --git a/src/test/ui/try-block/try-block-bad-type.stderr b/src/test/ui/try-block/try-block-bad-type.stderr index cadf3a841c9..2d1313d7d0e 100644 --- a/src/test/ui/try-block/try-block-bad-type.stderr +++ b/src/test/ui/try-block/try-block-bad-type.stderr @@ -13,13 +13,13 @@ LL | Err("")?; and 2 others = note: required by `from` -error[E0271]: type mismatch resolving `<std::result::Result<i32, i32> as Try>::Ok == &str` +error[E0271]: type mismatch resolving `<Result<i32, i32> as Try>::Ok == &str` --> $DIR/try-block-bad-type.rs:12:9 | LL | "" | ^^ expected `i32`, found `&str` -error[E0271]: type mismatch resolving `<std::result::Result<i32, i32> as Try>::Ok == ()` +error[E0271]: type mismatch resolving `<Result<i32, i32> as Try>::Ok == ()` --> $DIR/try-block-bad-type.rs:15:39 | LL | let res: Result<i32, i32> = try { }; diff --git a/src/test/ui/uninhabited/uninhabited-matches-feature-gated.stderr b/src/test/ui/uninhabited/uninhabited-matches-feature-gated.stderr index 7b999f50773..4f2f9e070fe 100644 --- a/src/test/ui/uninhabited/uninhabited-matches-feature-gated.stderr +++ b/src/test/ui/uninhabited/uninhabited-matches-feature-gated.stderr @@ -10,7 +10,7 @@ LL | Err(#[stable(feature = "rust1", since = "1.0.0")] E), | --- not covered | = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms - = note: the matched value is of type `std::result::Result<u32, &Void>` + = note: the matched value is of type `Result<u32, &Void>` error[E0004]: non-exhaustive patterns: type `&Void` is non-empty --> $DIR/uninhabited-matches-feature-gated.rs:15:19 @@ -64,7 +64,7 @@ LL | Err(#[stable(feature = "rust1", since = "1.0.0")] E), | --- not covered | = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms - = note: the matched value is of type `std::result::Result<u32, Void>` + = note: the matched value is of type `Result<u32, Void>` error[E0005]: refutable pattern in local binding: `Err(_)` not covered --> $DIR/uninhabited-matches-feature-gated.rs:37:9 @@ -79,7 +79,7 @@ LL | Err(#[stable(feature = "rust1", since = "1.0.0")] E), | = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html - = note: the matched value is of type `std::result::Result<u32, Void>` + = note: the matched value is of type `Result<u32, Void>` help: you might want to use `if let` to ignore the variant that isn't matched | LL | if let Ok(x) = x { /* */ } diff --git a/src/test/ui/unsized/unchanged-param.rs b/src/test/ui/unsized/unchanged-param.rs new file mode 100644 index 00000000000..83199e8112e --- /dev/null +++ b/src/test/ui/unsized/unchanged-param.rs @@ -0,0 +1,12 @@ +#![feature(relaxed_struct_unsize)] +// run-pass +// Test that we allow unsizing even if there is an unchanged param in the +// field getting unsized. +struct A<T, U: ?Sized + 'static>(T, B<T, U>); +struct B<T, U: ?Sized>(T, U); + +fn main() { + let x: A<[u32; 1], [u32; 1]> = A([0; 1], B([0; 1], [0; 1])); + let y: &A<[u32; 1], [u32]> = &x; + assert_eq!(y.1.1.len(), 1); +} diff --git a/src/test/ui/unsized/unsized-enum.stderr b/src/test/ui/unsized/unsized-enum.stderr index 795c7beab0a..3057d4789bd 100644 --- a/src/test/ui/unsized/unsized-enum.stderr +++ b/src/test/ui/unsized/unsized-enum.stderr @@ -13,7 +13,7 @@ help: you could relax the implicit `Sized` bound on `U` if it were used through --> $DIR/unsized-enum.rs:4:10 | LL | enum Foo<U> { FooSome(U), FooNone } - | ^ - ...if indirection was used here: `Box<U>` + | ^ - ...if indirection were used here: `Box<U>` | | | this could be changed to `U: ?Sized`... diff --git a/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr b/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr index 9efebe3aeff..9d8a1c67734 100644 --- a/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr +++ b/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr @@ -13,7 +13,7 @@ help: you could relax the implicit `Sized` bound on `Y` if it were used through --> $DIR/unsized-inherent-impl-self-type.rs:5:11 | LL | struct S5<Y>(Y); - | ^ - ...if indirection was used here: `Box<Y>` + | ^ - ...if indirection were used here: `Box<Y>` | | | this could be changed to `Y: ?Sized`... diff --git a/src/test/ui/unsized/unsized-struct.stderr b/src/test/ui/unsized/unsized-struct.stderr index e013b8fc69e..6661cf358b3 100644 --- a/src/test/ui/unsized/unsized-struct.stderr +++ b/src/test/ui/unsized/unsized-struct.stderr @@ -13,7 +13,7 @@ help: you could relax the implicit `Sized` bound on `T` if it were used through --> $DIR/unsized-struct.rs:4:12 | LL | struct Foo<T> { data: T } - | ^ - ...if indirection was used here: `Box<T>` + | ^ - ...if indirection were used here: `Box<T>` | | | this could be changed to `T: ?Sized`... diff --git a/src/test/ui/unsized/unsized-trait-impl-self-type.stderr b/src/test/ui/unsized/unsized-trait-impl-self-type.stderr index 516c750cb34..d1b590d8133 100644 --- a/src/test/ui/unsized/unsized-trait-impl-self-type.stderr +++ b/src/test/ui/unsized/unsized-trait-impl-self-type.stderr @@ -13,7 +13,7 @@ help: you could relax the implicit `Sized` bound on `Y` if it were used through --> $DIR/unsized-trait-impl-self-type.rs:8:11 | LL | struct S5<Y>(Y); - | ^ - ...if indirection was used here: `Box<Y>` + | ^ - ...if indirection were used here: `Box<Y>` | | | this could be changed to `Y: ?Sized`... diff --git a/src/test/ui/unused-crate-deps/extern-loc-bad-loctype.rs b/src/test/ui/unused-crate-deps/extern-loc-bad-loctype.rs new file mode 100644 index 00000000000..3e1527e2c2e --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-bad-loctype.rs @@ -0,0 +1,8 @@ +// --extern-location with bad location type + +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=badloc:in-the-test-file + +#![warn(unused_crate_dependencies)] + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-bad-loctype.stderr b/src/test/ui/unused-crate-deps/extern-loc-bad-loctype.stderr new file mode 100644 index 00000000000..12378f12557 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-bad-loctype.stderr @@ -0,0 +1,2 @@ +error: unknown location type `badloc`: use `raw` or `json` + diff --git a/src/test/ui/unused-crate-deps/extern-loc-defl-json.rs b/src/test/ui/unused-crate-deps/extern-loc-defl-json.rs new file mode 100644 index 00000000000..a023f535b81 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-defl-json.rs @@ -0,0 +1,10 @@ +// Default extern location from name and path if one isn't specified + +// check-pass +// aux-crate:bar=bar.rs +// compile-flags:--error-format json + +#![warn(unused_crate_dependencies)] +//~^ WARNING external crate `bar` unused in + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-defl-json.stderr b/src/test/ui/unused-crate-deps/extern-loc-defl-json.stderr new file mode 100644 index 00000000000..cee3f6c1495 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-defl-json.stderr @@ -0,0 +1,17 @@ +{"message":"external crate `bar` unused in `extern_loc_defl_json`: remove the dependency or add `use bar as _;`","code":{"code":"unused_crate_dependencies","explanation":null},"level":"warning","spans":[{"file_name":"$DIR/extern-loc-defl-json.rs","byte_start":146,"byte_end":146,"line_start":7,"line_end":7,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"#![warn(unused_crate_dependencies)]","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"the lint level is defined here","code":null,"level":"note","spans":[{"file_name":"$DIR/extern-loc-defl-json.rs","byte_start":154,"byte_end":179,"line_start":7,"line_end":7,"column_start":9,"column_end":34,"is_primary":true,"text":[{"text":"#![warn(unused_crate_dependencies)]","highlight_start":9,"highlight_end":34}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":null},{"message":"remove unnecessary dependency `bar`","code":null,"level":"help","spans":[],"children":[],"rendered":null},{"message":"json extern location","code":null,"level":"help","spans":[],"children":[],"rendered":null,"tool_metadata":{"name":"bar"}}],"rendered":"warning: external crate `bar` unused in `extern_loc_defl_json`: remove the dependency or add `use bar as _;` + --> $DIR/extern-loc-defl-json.rs:7:1 + | +LL | #![warn(unused_crate_dependencies)] + | ^ + | +note: the lint level is defined here + --> $DIR/extern-loc-defl-json.rs:7:9 + | +LL | #![warn(unused_crate_dependencies)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: remove unnecessary dependency `bar` + +"} +{"message":"1 warning emitted","code":null,"level":"warning","spans":[],"children":[],"rendered":"warning: 1 warning emitted + +"} diff --git a/src/test/ui/unused-crate-deps/extern-loc-json-bad-json.rs b/src/test/ui/unused-crate-deps/extern-loc-json-bad-json.rs new file mode 100644 index 00000000000..6fdf710a126 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-json-bad-json.rs @@ -0,0 +1,8 @@ +// --extern-location with a raw reference + +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=json:[{"malformed + +#![warn(unused_crate_dependencies)] + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-json-bad-json.stderr b/src/test/ui/unused-crate-deps/extern-loc-json-bad-json.stderr new file mode 100644 index 00000000000..20d606372e0 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-json-bad-json.stderr @@ -0,0 +1,2 @@ +error: `--extern-location`: malformed json location `[{"malformed` + diff --git a/src/test/ui/unused-crate-deps/extern-loc-json-json.rs b/src/test/ui/unused-crate-deps/extern-loc-json-json.rs new file mode 100644 index 00000000000..02a9869151f --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-json-json.rs @@ -0,0 +1,10 @@ +// --extern-location with a raw reference + +// check-pass +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=json:{"key":123,"value":{}} --error-format json + +#![warn(unused_crate_dependencies)] +//~^ WARNING external crate `bar` unused in + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-json-json.stderr b/src/test/ui/unused-crate-deps/extern-loc-json-json.stderr new file mode 100644 index 00000000000..5fc8397e469 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-json-json.stderr @@ -0,0 +1,17 @@ +{"message":"external crate `bar` unused in `extern_loc_json_json`: remove the dependency or add `use bar as _;`","code":{"code":"unused_crate_dependencies","explanation":null},"level":"warning","spans":[{"file_name":"$DIR/extern-loc-json-json.rs","byte_start":169,"byte_end":169,"line_start":7,"line_end":7,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"#![warn(unused_crate_dependencies)]","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"the lint level is defined here","code":null,"level":"note","spans":[{"file_name":"$DIR/extern-loc-json-json.rs","byte_start":177,"byte_end":202,"line_start":7,"line_end":7,"column_start":9,"column_end":34,"is_primary":true,"text":[{"text":"#![warn(unused_crate_dependencies)]","highlight_start":9,"highlight_end":34}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":null},{"message":"remove unnecessary dependency `bar`","code":null,"level":"help","spans":[],"children":[],"rendered":null},{"message":"json extern location","code":null,"level":"help","spans":[],"children":[],"rendered":null,"tool_metadata":{"key":123,"value":{}}}],"rendered":"warning: external crate `bar` unused in `extern_loc_json_json`: remove the dependency or add `use bar as _;` + --> $DIR/extern-loc-json-json.rs:7:1 + | +LL | #![warn(unused_crate_dependencies)] + | ^ + | +note: the lint level is defined here + --> $DIR/extern-loc-json-json.rs:7:9 + | +LL | #![warn(unused_crate_dependencies)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: remove unnecessary dependency `bar` + +"} +{"message":"1 warning emitted","code":null,"level":"warning","spans":[],"children":[],"rendered":"warning: 1 warning emitted + +"} diff --git a/src/test/ui/unused-crate-deps/extern-loc-json.rs b/src/test/ui/unused-crate-deps/extern-loc-json.rs new file mode 100644 index 00000000000..212610d532e --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-json.rs @@ -0,0 +1,10 @@ +// --extern-location with a raw reference + +// check-pass +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=json:{"key":123,"value":{}} + +#![warn(unused_crate_dependencies)] +//~^ WARNING external crate `bar` unused in + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-json.stderr b/src/test/ui/unused-crate-deps/extern-loc-json.stderr new file mode 100644 index 00000000000..a6bbc0da1c6 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-json.stderr @@ -0,0 +1,15 @@ +warning: external crate `bar` unused in `extern_loc_json`: remove the dependency or add `use bar as _;` + --> $DIR/extern-loc-json.rs:7:1 + | +LL | #![warn(unused_crate_dependencies)] + | ^ + | +note: the lint level is defined here + --> $DIR/extern-loc-json.rs:7:9 + | +LL | #![warn(unused_crate_dependencies)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: remove unnecessary dependency `bar` + +warning: 1 warning emitted + diff --git a/src/test/ui/unused-crate-deps/extern-loc-missing-loc.rs b/src/test/ui/unused-crate-deps/extern-loc-missing-loc.rs new file mode 100644 index 00000000000..9339a004d3b --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-missing-loc.rs @@ -0,0 +1,8 @@ +// --extern-location with a raw reference + +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar + +#![warn(unused_crate_dependencies)] + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-missing-loc.stderr b/src/test/ui/unused-crate-deps/extern-loc-missing-loc.stderr new file mode 100644 index 00000000000..4584fbfb67f --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-missing-loc.stderr @@ -0,0 +1,2 @@ +error: `--extern-location`: specify location for extern crate `bar` + diff --git a/src/test/ui/unused-crate-deps/extern-loc-missing-loctype.rs b/src/test/ui/unused-crate-deps/extern-loc-missing-loctype.rs new file mode 100644 index 00000000000..4768365a653 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-missing-loctype.rs @@ -0,0 +1,8 @@ +// --extern-location with no type + +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=missing-loc-type + +#![warn(unused_crate_dependencies)] + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-missing-loctype.stderr b/src/test/ui/unused-crate-deps/extern-loc-missing-loctype.stderr new file mode 100644 index 00000000000..d0c36ebeb14 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-missing-loctype.stderr @@ -0,0 +1,2 @@ +error: unknown location type `missing-loc-type`: use `raw` or `json` + diff --git a/src/test/ui/unused-crate-deps/extern-loc-raw-json.rs b/src/test/ui/unused-crate-deps/extern-loc-raw-json.rs new file mode 100644 index 00000000000..207615ccc87 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-raw-json.rs @@ -0,0 +1,10 @@ +// --extern-location with a raw reference + +// check-pass +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=raw:in-the-test-file --error-format json + +#![warn(unused_crate_dependencies)] +//~^ WARNING external crate `bar` unused in + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-raw-json.stderr b/src/test/ui/unused-crate-deps/extern-loc-raw-json.stderr new file mode 100644 index 00000000000..25f099927fd --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-raw-json.stderr @@ -0,0 +1,17 @@ +{"message":"external crate `bar` unused in `extern_loc_raw_json`: remove the dependency or add `use bar as _;`","code":{"code":"unused_crate_dependencies","explanation":null},"level":"warning","spans":[{"file_name":"$DIR/extern-loc-raw-json.rs","byte_start":162,"byte_end":162,"line_start":7,"line_end":7,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"#![warn(unused_crate_dependencies)]","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"the lint level is defined here","code":null,"level":"note","spans":[{"file_name":"$DIR/extern-loc-raw-json.rs","byte_start":170,"byte_end":195,"line_start":7,"line_end":7,"column_start":9,"column_end":34,"is_primary":true,"text":[{"text":"#![warn(unused_crate_dependencies)]","highlight_start":9,"highlight_end":34}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":null},{"message":"remove unnecessary dependency `bar` at `in-the-test-file`","code":null,"level":"help","spans":[],"children":[],"rendered":null},{"message":"raw extern location","code":null,"level":"help","spans":[{"file_name":"$DIR/extern-loc-raw-json.rs","byte_start":0,"byte_end":0,"line_start":1,"line_end":1,"column_start":1,"column_end":1,"is_primary":true,"text":[],"label":null,"suggested_replacement":"in-the-test-file","suggestion_applicability":"Unspecified","expansion":null}],"children":[],"rendered":null},{"message":"json extern location","code":null,"level":"help","spans":[],"children":[],"rendered":null,"tool_metadata":"in-the-test-file"}],"rendered":"warning: external crate `bar` unused in `extern_loc_raw_json`: remove the dependency or add `use bar as _;` + --> $DIR/extern-loc-raw-json.rs:7:1 + | +LL | #![warn(unused_crate_dependencies)] + | ^ + | +note: the lint level is defined here + --> $DIR/extern-loc-raw-json.rs:7:9 + | +LL | #![warn(unused_crate_dependencies)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: remove unnecessary dependency `bar` at `in-the-test-file` + +"} +{"message":"1 warning emitted","code":null,"level":"warning","spans":[],"children":[],"rendered":"warning: 1 warning emitted + +"} diff --git a/src/test/ui/unused-crate-deps/extern-loc-raw-missing-loc.rs b/src/test/ui/unused-crate-deps/extern-loc-raw-missing-loc.rs new file mode 100644 index 00000000000..65b64268394 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-raw-missing-loc.rs @@ -0,0 +1,8 @@ +// --extern-location with a raw reference + +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=raw + +#![warn(unused_crate_dependencies)] + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-raw-missing-loc.stderr b/src/test/ui/unused-crate-deps/extern-loc-raw-missing-loc.stderr new file mode 100644 index 00000000000..4b51266e4f6 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-raw-missing-loc.stderr @@ -0,0 +1,2 @@ +error: `--extern-location`: missing `raw` location + diff --git a/src/test/ui/unused-crate-deps/extern-loc-raw.rs b/src/test/ui/unused-crate-deps/extern-loc-raw.rs new file mode 100644 index 00000000000..fc3fed1e10e --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-raw.rs @@ -0,0 +1,10 @@ +// --extern-location with a raw reference + +// check-pass +// aux-crate:bar=bar.rs +// compile-flags:--extern-location bar=raw:in-the-test-file + +#![warn(unused_crate_dependencies)] +//~^ WARNING external crate `bar` unused in + +fn main() {} diff --git a/src/test/ui/unused-crate-deps/extern-loc-raw.stderr b/src/test/ui/unused-crate-deps/extern-loc-raw.stderr new file mode 100644 index 00000000000..2cdd0055866 --- /dev/null +++ b/src/test/ui/unused-crate-deps/extern-loc-raw.stderr @@ -0,0 +1,15 @@ +warning: external crate `bar` unused in `extern_loc_raw`: remove the dependency or add `use bar as _;` + --> $DIR/extern-loc-raw.rs:7:1 + | +LL | #![warn(unused_crate_dependencies)] + | ^ + | +note: the lint level is defined here + --> $DIR/extern-loc-raw.rs:7:9 + | +LL | #![warn(unused_crate_dependencies)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: remove unnecessary dependency `bar` at `in-the-test-file` + +warning: 1 warning emitted + diff --git a/src/test/ui/unused-crate-deps/libfib.stderr b/src/test/ui/unused-crate-deps/libfib.stderr index 15833126bd6..479f51bff46 100644 --- a/src/test/ui/unused-crate-deps/libfib.stderr +++ b/src/test/ui/unused-crate-deps/libfib.stderr @@ -5,6 +5,7 @@ LL | pub fn fib(n: u32) -> Vec<u32> { | ^ | = note: requested on the command line with `-W unused-crate-dependencies` + = help: remove unnecessary dependency `bar` warning: 1 warning emitted diff --git a/src/test/ui/unused-crate-deps/test.mk b/src/test/ui/unused-crate-deps/test.mk new file mode 100644 index 00000000000..0b98b4e44fb --- /dev/null +++ b/src/test/ui/unused-crate-deps/test.mk @@ -0,0 +1,7 @@ +# Everyone uses make for building Rust + +foo: bar.rlib + $(RUSTC) --crate-type bin --extern bar=bar.rlib + +%.rlib: %.rs + $(RUSTC) --crate-type lib $< diff --git a/src/test/ui/unused-crate-deps/unused-aliases.stderr b/src/test/ui/unused-crate-deps/unused-aliases.stderr index c8c6c4507b0..1142d156d0e 100644 --- a/src/test/ui/unused-crate-deps/unused-aliases.stderr +++ b/src/test/ui/unused-crate-deps/unused-aliases.stderr @@ -9,6 +9,7 @@ note: the lint level is defined here | LL | #![warn(unused_crate_dependencies)] | ^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: remove unnecessary dependency `barbar` warning: 1 warning emitted diff --git a/src/test/ui/unused-crate-deps/warn-attr.stderr b/src/test/ui/unused-crate-deps/warn-attr.stderr index 0d38315704b..29667d9525c 100644 --- a/src/test/ui/unused-crate-deps/warn-attr.stderr +++ b/src/test/ui/unused-crate-deps/warn-attr.stderr @@ -9,6 +9,7 @@ note: the lint level is defined here | LL | #![warn(unused_crate_dependencies)] | ^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: remove unnecessary dependency `bar` warning: 1 warning emitted diff --git a/src/test/ui/unused-crate-deps/warn-cmdline-static.stderr b/src/test/ui/unused-crate-deps/warn-cmdline-static.stderr index 65956461d64..2c0c9215129 100644 --- a/src/test/ui/unused-crate-deps/warn-cmdline-static.stderr +++ b/src/test/ui/unused-crate-deps/warn-cmdline-static.stderr @@ -5,6 +5,7 @@ LL | fn main() {} | ^ | = note: requested on the command line with `-W unused-crate-dependencies` + = help: remove unnecessary dependency `bar` warning: 1 warning emitted diff --git a/src/test/ui/unused-crate-deps/warn-cmdline.stderr b/src/test/ui/unused-crate-deps/warn-cmdline.stderr index ea675ba9a1e..2cd49218f5a 100644 --- a/src/test/ui/unused-crate-deps/warn-cmdline.stderr +++ b/src/test/ui/unused-crate-deps/warn-cmdline.stderr @@ -5,6 +5,7 @@ LL | fn main() {} | ^ | = note: requested on the command line with `-W unused-crate-dependencies` + = help: remove unnecessary dependency `bar` warning: 1 warning emitted diff --git a/src/test/ui/wf/wf-fn-where-clause.stderr b/src/test/ui/wf/wf-fn-where-clause.stderr index 988cb2fa548..22598e58bd7 100644 --- a/src/test/ui/wf/wf-fn-where-clause.stderr +++ b/src/test/ui/wf/wf-fn-where-clause.stderr @@ -28,7 +28,7 @@ help: you could relax the implicit `Sized` bound on `T` if it were used through LL | struct Vec<T> { | ^ this could be changed to `T: ?Sized`... LL | t: T, - | - ...if indirection was used here: `Box<T>` + | - ...if indirection were used here: `Box<T>` error[E0038]: the trait `Copy` cannot be made into an object --> $DIR/wf-fn-where-clause.rs:12:16 diff --git a/src/tools/clippy/Cargo.toml b/src/tools/clippy/Cargo.toml index e60aa472846..e7755c46eb8 100644 --- a/src/tools/clippy/Cargo.toml +++ b/src/tools/clippy/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "clippy" -version = "0.1.51" +version = "0.1.52" authors = [ "Manish Goregaokar <manishsmail@gmail.com>", "Andre Bogus <bogusandre@gmail.com>", diff --git a/src/tools/clippy/clippy_lints/Cargo.toml b/src/tools/clippy/clippy_lints/Cargo.toml index a9516560a61..840341fefc6 100644 --- a/src/tools/clippy/clippy_lints/Cargo.toml +++ b/src/tools/clippy/clippy_lints/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "clippy_lints" # begin automatic update -version = "0.1.51" +version = "0.1.52" # end automatic update authors = [ "Manish Goregaokar <manishsmail@gmail.com>", diff --git a/src/tools/clippy/clippy_lints/src/misc_early.rs b/src/tools/clippy/clippy_lints/src/misc_early.rs index 5bc45c87874..84a0df92f5b 100644 --- a/src/tools/clippy/clippy_lints/src/misc_early.rs +++ b/src/tools/clippy/clippy_lints/src/misc_early.rs @@ -1,4 +1,4 @@ -use crate::utils::{constants, snippet_opt, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then}; +use crate::utils::{snippet_opt, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then}; use rustc_ast::ast::{ BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability, NodeId, Pat, PatKind, UnOp, @@ -6,6 +6,7 @@ use rustc_ast::ast::{ use rustc_ast::visit::FnKind; use rustc_data_structures::fx::FxHashMap; use rustc_errors::Applicability; +use rustc_hir::PrimTy; use rustc_lint::{EarlyContext, EarlyLintPass, LintContext}; use rustc_middle::lint::in_external_macro; use rustc_session::{declare_lint_pass, declare_tool_lint}; @@ -264,13 +265,12 @@ impl EarlyLintPass for MiscEarlyLints { fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) { for param in &gen.params { if let GenericParamKind::Type { .. } = param.kind { - let name = param.ident.as_str(); - if constants::BUILTIN_TYPES.contains(&&*name) { + if let Some(prim_ty) = PrimTy::from_name(param.ident.name) { span_lint( cx, BUILTIN_TYPE_SHADOW, param.ident.span, - &format!("this generic shadows the built-in type `{}`", name), + &format!("this generic shadows the built-in type `{}`", prim_ty.name()), ); } } diff --git a/src/tools/clippy/clippy_lints/src/utils/constants.rs b/src/tools/clippy/clippy_lints/src/utils/constants.rs deleted file mode 100644 index 522932f054d..00000000000 --- a/src/tools/clippy/clippy_lints/src/utils/constants.rs +++ /dev/null @@ -1,13 +0,0 @@ -//! This module contains some useful constants. - -#![deny(clippy::missing_docs_in_private_items)] - -/// List of the built-in types names. -/// -/// See also [the reference][reference-types] for a list of such types. -/// -/// [reference-types]: https://doc.rust-lang.org/reference/types.html -pub const BUILTIN_TYPES: &[&str] = &[ - "i8", "u8", "i16", "u16", "i32", "u32", "i64", "u64", "i128", "u128", "isize", "usize", "f32", "f64", "bool", - "str", "char", -]; diff --git a/src/tools/clippy/clippy_lints/src/utils/mod.rs b/src/tools/clippy/clippy_lints/src/utils/mod.rs index ef45f9fdcd5..de1538233a8 100644 --- a/src/tools/clippy/clippy_lints/src/utils/mod.rs +++ b/src/tools/clippy/clippy_lints/src/utils/mod.rs @@ -8,7 +8,6 @@ pub mod author; pub mod camel_case; pub mod comparisons; pub mod conf; -pub mod constants; mod diagnostics; pub mod eager_or_lazy; pub mod higher; diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs index c8e76743231..cde4bfe288d 100644 --- a/src/tools/compiletest/src/common.rs +++ b/src/tools/compiletest/src/common.rs @@ -240,8 +240,8 @@ pub struct Config { /// Run ignored tests pub run_ignored: bool, - /// Only run tests that match this filter - pub filter: Option<String>, + /// Only run tests that match these filters + pub filters: Vec<String>, /// Exactly match the filter, rather than a substring pub filter_exact: bool, diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs index 688cf930033..3fde24e8a7f 100644 --- a/src/tools/compiletest/src/main.rs +++ b/src/tools/compiletest/src/main.rs @@ -221,7 +221,7 @@ pub fn parse_config(args: Vec<String>) -> Config { suite: matches.opt_str("suite").unwrap(), debugger: None, run_ignored, - filter: matches.free.first().cloned(), + filters: matches.free.clone(), filter_exact: matches.opt_present("exact"), force_pass_mode: matches.opt_str("pass").map(|mode| { mode.parse::<PassMode>() @@ -280,7 +280,7 @@ pub fn log_config(config: &Config) { logv(c, format!("stage_id: {}", config.stage_id)); logv(c, format!("mode: {}", config.mode)); logv(c, format!("run_ignored: {}", config.run_ignored)); - logv(c, format!("filter: {}", opt_str(&config.filter))); + logv(c, format!("filters: {:?}", config.filters)); logv(c, format!("filter_exact: {}", config.filter_exact)); logv( c, @@ -465,7 +465,7 @@ fn configure_lldb(config: &Config) -> Option<Config> { pub fn test_opts(config: &Config) -> test::TestOpts { test::TestOpts { exclude_should_panic: false, - filter: config.filter.clone(), + filters: config.filters.clone(), filter_exact: config.filter_exact, run_ignored: if config.run_ignored { test::RunIgnored::Yes } else { test::RunIgnored::No }, format: if config.quiet { test::OutputFormat::Terse } else { test::OutputFormat::Pretty }, diff --git a/src/tools/miri b/src/tools/miri -Subproject 4cf36f285084f8f841f3cff7b29d44b1d95ee1d +Subproject 54bbbd13ac532deed80416295a224ce12547a40 diff --git a/src/tools/remote-test-server/src/main.rs b/src/tools/remote-test-server/src/main.rs index d92758eb747..cd9d5300964 100644 --- a/src/tools/remote-test-server/src/main.rs +++ b/src/tools/remote-test-server/src/main.rs @@ -218,25 +218,19 @@ fn handle_run(socket: TcpStream, work: &Path, tmp: &Path, lock: &Mutex<()>, conf cmd.args(args); cmd.envs(env); + // On windows, libraries are just searched in the executable directory, + // system directories, PWD, and PATH, in that order. PATH is the only one + // we can change for this. + let library_path = if cfg!(windows) { "PATH" } else { "LD_LIBRARY_PATH" }; + // Support libraries were uploaded to `work` earlier, so make sure that's // in `LD_LIBRARY_PATH`. Also include our own current dir which may have // had some libs uploaded. - if cfg!(windows) { - // On windows, libraries are just searched in the executable directory, - // system directories, PWD, and PATH, in that order. PATH is the only one - // we can change for this. - cmd.env( - "PATH", - env::join_paths( - std::iter::once(work.to_owned()) - .chain(std::iter::once(path.clone())) - .chain(env::split_paths(&env::var_os("PATH").unwrap())), - ) - .unwrap(), - ); - } else { - cmd.env("LD_LIBRARY_PATH", format!("{}:{}", work.display(), path.display())); + let mut paths = vec![work.to_owned(), path.clone()]; + if let Some(library_path) = env::var_os(library_path) { + paths.extend(env::split_paths(&library_path)); } + cmd.env(library_path, env::join_paths(paths).unwrap()); // Some tests assume RUST_TEST_TMPDIR exists cmd.env("RUST_TEST_TMPDIR", tmp.to_owned()); diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs index 6697fbd1be2..9f68c55ec97 100644 --- a/src/tools/tidy/src/style.rs +++ b/src/tools/tidy/src/style.rs @@ -18,6 +18,8 @@ use std::path::Path; +/// Error code markdown is restricted to 80 columns because they can be +/// displayed on the console with --example. const ERROR_CODE_COLS: usize = 80; const COLS: usize = 100; @@ -55,9 +57,9 @@ enum LIUState { /// Lines of this form are allowed to be overlength, because Markdown /// offers no way to split a line in the middle of a URL, and the lengths /// of URLs to external references are beyond our control. -fn line_is_url(columns: usize, line: &str) -> bool { - // more basic check for error_codes.rs, to avoid complexity in implementing two state machines - if columns == ERROR_CODE_COLS { +fn line_is_url(is_error_code: bool, columns: usize, line: &str) -> bool { + // more basic check for markdown, to avoid complexity in implementing two state machines + if is_error_code { return line.starts_with('[') && line.contains("]:") && line.contains("http"); } @@ -93,8 +95,13 @@ fn line_is_url(columns: usize, line: &str) -> bool { /// Returns `true` if `line` is allowed to be longer than the normal limit. /// Currently there is only one exception, for long URLs, but more /// may be added in the future. -fn long_line_is_ok(max_columns: usize, line: &str) -> bool { - if line_is_url(max_columns, line) { +fn long_line_is_ok(extension: &str, is_error_code: bool, max_columns: usize, line: &str) -> bool { + if extension != "md" || is_error_code { + if line_is_url(is_error_code, max_columns, line) { + return true; + } + } else if extension == "md" { + // non-error code markdown is allowed to be any length return true; } @@ -158,8 +165,36 @@ pub fn is_in(full_path: &Path, parent_folder_to_find: &str, folder_to_find: &str } } +fn skip_markdown_path(path: &Path) -> bool { + // These aren't ready for tidy. + const SKIP_MD: &[&str] = &[ + "src/doc/edition-guide", + "src/doc/embedded-book", + "src/doc/nomicon", + "src/doc/reference", + "src/doc/rust-by-example", + "src/doc/rustc-dev-guide", + ]; + SKIP_MD.iter().any(|p| path.ends_with(p)) +} + +fn is_unexplained_ignore(extension: &str, line: &str) -> bool { + if !line.ends_with("```ignore") && !line.ends_with("```rust,ignore") { + return false; + } + if extension == "md" && line.trim().starts_with("//") { + // Markdown examples may include doc comments with ignore inside a + // code block. + return false; + } + true +} + pub fn check(path: &Path, bad: &mut bool) { - super::walk(path, &mut super::filter_dirs, &mut |entry, contents| { + fn skip(path: &Path) -> bool { + super::filter_dirs(path) || skip_markdown_path(path) + } + super::walk(path, &mut skip, &mut |entry, contents| { let file = entry.path(); let filename = file.file_name().unwrap().to_string_lossy(); let extensions = [".rs", ".py", ".js", ".sh", ".c", ".cpp", ".h", ".md", ".css"]; @@ -176,13 +211,6 @@ pub fn check(path: &Path, bad: &mut bool) { a.ends_with("src/doc/book") }); - if filename.ends_with(".md") - && file.parent().unwrap().file_name().unwrap().to_string_lossy() != "error_codes" - { - // We don't want to check all ".md" files (almost of of them aren't compliant - // currently), just the long error code explanation ones. - return; - } if is_style_file && !is_in(file, "src", "librustdoc") { // We only check CSS files in rustdoc. return; @@ -192,11 +220,10 @@ pub fn check(path: &Path, bad: &mut bool) { tidy_error!(bad, "{}: empty file", file.display()); } - let max_columns = if filename == "error_codes.rs" || filename.ends_with(".md") { - ERROR_CODE_COLS - } else { - COLS - }; + let extension = file.extension().unwrap().to_string_lossy(); + let is_error_code = extension == "md" && is_in(file, "src", "error_codes"); + + let max_columns = if is_error_code { ERROR_CODE_COLS } else { COLS }; let can_contain = contents.contains("// ignore-tidy-") || contents.contains("# ignore-tidy-") @@ -227,7 +254,7 @@ pub fn check(path: &Path, bad: &mut bool) { }; if !under_rustfmt && line.chars().count() > max_columns - && !long_line_is_ok(max_columns, line) + && !long_line_is_ok(&extension, is_error_code, max_columns, line) { suppressible_tidy_err!( err, @@ -280,7 +307,7 @@ pub fn check(path: &Path, bad: &mut bool) { "copyright notices attributed to the Rust Project Developers are deprecated" ); } - if line.ends_with("```ignore") || line.ends_with("```rust,ignore") { + if is_unexplained_ignore(&extension, line) { err(UNEXPLAINED_IGNORE_DOCTEST_INFO); } if filename.ends_with(".cpp") && line.contains("llvm_unreachable") { diff --git a/src/version b/src/version index ba0a719118c..a63cb35e6f0 100644 --- a/src/version +++ b/src/version @@ -1 +1 @@ -1.51.0 +1.52.0 |