| - // MIR for `chained_conditions` before JumpThreading | |
| + // MIR for `chained_conditions` after JumpThreading | |
| fn chained_conditions() -> u8 { | |
| let mut _0: u8; | |
| let _1: chained_conditions::BacktraceStyle; | |
| let mut _2: std::option::Option<std::string::String>; | |
| let mut _3: &std::option::Option<std::string::String>; | |
| let mut _4: isize; | |
| let _5: std::string::String; | |
| let _6: &std::string::String; | |
| let mut _7: bool; | |
| let mut _8: &&std::string::String; | |
| let _9: &std::string::String; | |
| let mut _10: &&str; | |
| let _11: &str; | |
| let _12: std::string::String; | |
| let _13: &std::string::String; | |
| let mut _14: bool; | |
| let mut _15: &&std::string::String; | |
| let _16: &std::string::String; | |
| let mut _17: &&str; | |
| let _18: &str; | |
| let mut _19: isize; | |
| let mut _20: &&str; | |
| let mut _21: &&str; | |
| let mut _22: bool; | |
| let mut _23: bool; | |
| let mut _24: isize; | |
| let mut _25: isize; | |
| let mut _26: isize; | |
| scope 1 { | |
| debug format => _1; | |
| } | |
| scope 2 { | |
| debug x => _5; | |
| debug x => _6; | |
| } | |
| scope 3 { | |
| debug x => _12; | |
| debug x => _13; | |
| } | |
| scope 4 (inlined std::cmp::impls::<impl PartialEq<&str> for &String>::eq) { | |
| let mut _27: &std::string::String; | |
| let mut _28: &str; | |
| scope 5 (inlined <String as PartialEq<str>>::eq) { | |
| scope 6 (inlined #[track_caller] <String as Index<RangeFull>>::index) { | |
| let _29: &str; | |
| scope 7 (inlined String::as_str) { | |
| let _30: &[u8]; | |
| scope 8 (inlined Vec::<u8>::as_slice) { | |
| let _31: *const [u8]; | |
| let mut _32: *const u8; | |
| let mut _33: usize; | |
| scope 9 (inlined Vec::<u8>::as_ptr) { | |
| scope 10 (inlined alloc::raw_vec::RawVec::<u8>::ptr) { | |
| scope 11 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) { | |
| scope 12 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) { | |
| let mut _34: std::ptr::NonNull<u8>; | |
| scope 13 (inlined std::ptr::Unique::<u8>::cast::<u8>) { | |
| scope 14 (inlined NonNull::<u8>::cast::<u8>) { | |
| scope 15 (inlined NonNull::<u8>::as_ptr) { | |
| } | |
| } | |
| } | |
| scope 16 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) { | |
| } | |
| } | |
| scope 17 (inlined NonNull::<u8>::as_ptr) { | |
| } | |
| } | |
| } | |
| } | |
| } | |
| scope 18 (inlined from_utf8_unchecked) { | |
| } | |
| } | |
| scope 19 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) { | |
| } | |
| } | |
| scope 20 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) { | |
| scope 21 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) { | |
| } | |
| } | |
| scope 22 (inlined core::str::traits::<impl PartialEq for str>::eq) { | |
| let mut _35: &&[u8]; | |
| let _36: &[u8]; | |
| let mut _37: &&[u8]; | |
| let _38: &[u8]; | |
| scope 23 (inlined core::str::<impl str>::as_bytes) { | |
| } | |
| scope 24 (inlined core::str::<impl str>::as_bytes) { | |
| } | |
| scope 25 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) { | |
| scope 26 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) { | |
| let _39: usize; | |
| let mut _40: bool; | |
| let mut _41: usize; | |
| let mut _42: *const u8; | |
| let mut _43: *const u8; | |
| scope 27 { | |
| scope 28 (inlined core::slice::<impl [u8]>::as_ptr) { | |
| let mut _44: *const [u8]; | |
| } | |
| scope 29 (inlined core::slice::<impl [u8]>::as_ptr) { | |
| let mut _45: *const [u8]; | |
| } | |
| scope 30 (inlined <u8 as core::slice::cmp::SlicePartialEq<u8>>::equal_same_length) { | |
| let mut _46: i32; | |
| scope 31 { | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| scope 32 (inlined std::cmp::impls::<impl PartialEq<&str> for &String>::eq) { | |
| let mut _47: &std::string::String; | |
| let mut _48: &str; | |
| scope 33 (inlined <String as PartialEq<str>>::eq) { | |
| scope 34 (inlined #[track_caller] <String as Index<RangeFull>>::index) { | |
| let _49: &str; | |
| scope 35 (inlined String::as_str) { | |
| let _50: &[u8]; | |
| scope 36 (inlined Vec::<u8>::as_slice) { | |
| let _51: *const [u8]; | |
| let mut _52: *const u8; | |
| let mut _53: usize; | |
| scope 37 (inlined Vec::<u8>::as_ptr) { | |
| scope 38 (inlined alloc::raw_vec::RawVec::<u8>::ptr) { | |
| scope 39 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) { | |
| scope 40 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) { | |
| let mut _54: std::ptr::NonNull<u8>; | |
| scope 41 (inlined std::ptr::Unique::<u8>::cast::<u8>) { | |
| scope 42 (inlined NonNull::<u8>::cast::<u8>) { | |
| scope 43 (inlined NonNull::<u8>::as_ptr) { | |
| } | |
| } | |
| } | |
| scope 44 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) { | |
| } | |
| } | |
| scope 45 (inlined NonNull::<u8>::as_ptr) { | |
| } | |
| } | |
| } | |
| } | |
| } | |
| scope 46 (inlined from_utf8_unchecked) { | |
| } | |
| } | |
| scope 47 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) { | |
| } | |
| } | |
| scope 48 (inlined #[track_caller] core::str::traits::<impl Index<RangeFull> for str>::index) { | |
| scope 49 (inlined #[track_caller] core::str::traits::<impl SliceIndex<str> for RangeFull>::index) { | |
| } | |
| } | |
| scope 50 (inlined core::str::traits::<impl PartialEq for str>::eq) { | |
| let mut _55: &&[u8]; | |
| let _56: &[u8]; | |
| let mut _57: &&[u8]; | |
| let _58: &[u8]; | |
| scope 51 (inlined core::str::<impl str>::as_bytes) { | |
| } | |
| scope 52 (inlined core::str::<impl str>::as_bytes) { | |
| } | |
| scope 53 (inlined std::cmp::impls::<impl PartialEq for &[u8]>::eq) { | |
| scope 54 (inlined core::slice::cmp::<impl PartialEq for [u8]>::eq) { | |
| let _59: usize; | |
| let mut _60: bool; | |
| let mut _61: usize; | |
| let mut _62: *const u8; | |
| let mut _63: *const u8; | |
| scope 55 { | |
| scope 56 (inlined core::slice::<impl [u8]>::as_ptr) { | |
| let mut _64: *const [u8]; | |
| } | |
| scope 57 (inlined core::slice::<impl [u8]>::as_ptr) { | |
| let mut _65: *const [u8]; | |
| } | |
| scope 58 (inlined <u8 as core::slice::cmp::SlicePartialEq<u8>>::equal_same_length) { | |
| let mut _66: i32; | |
| scope 59 { | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| bb0: { | |
| _22 = const false; | |
| _23 = const false; | |
| StorageLive(_1); | |
| StorageLive(_2); | |
| _22 = const true; | |
| _23 = const true; | |
| _2 = env_var() -> [return: bb1, unwind continue]; | |
| } | |
| bb1: { | |
| _4 = discriminant(_2); | |
| switchInt(move _4) -> [0: bb3, 1: bb4, otherwise: bb2]; | |
| } | |
| bb2: { | |
| unreachable; | |
| } | |
| bb3: { | |
| _1 = chained_conditions::BacktraceStyle::Off; | |
| - goto -> bb19; | |
| + goto -> bb33; | |
| } | |
| bb4: { | |
| StorageLive(_6); | |
| _6 = &((_2 as Some).0: std::string::String); | |
| StorageLive(_7); | |
| StorageLive(_8); | |
| StorageLive(_9); | |
| _9 = &(*_6); | |
| _8 = &_9; | |
| StorageLive(_10); | |
| _21 = const chained_conditions::promoted[1]; | |
| _10 = &(*_21); | |
| StorageLive(_27); | |
| StorageLive(_28); | |
| _27 = no_retag copy (*_8); | |
| _28 = no_retag copy (*_10); | |
| StorageLive(_29); | |
| StorageLive(_30); | |
| StorageLive(_31); | |
| StorageLive(_32); | |
| StorageLive(_34); | |
| _34 = copy ((((((*_27).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>); | |
| _32 = copy _34 as *const u8 (Transmute); | |
| StorageDead(_34); | |
| StorageLive(_33); | |
| _33 = copy (((*_27).0: std::vec::Vec<u8>).1: usize); | |
| _31 = *const [u8] from (copy _32, move _33); | |
| StorageDead(_33); | |
| StorageDead(_32); | |
| _30 = &(*_31); | |
| StorageDead(_31); | |
| _29 = copy _30 as &str (Transmute); | |
| StorageDead(_30); | |
| StorageLive(_36); | |
| StorageLive(_38); | |
| _36 = copy _29 as &[u8] (Transmute); | |
| _38 = copy _28 as &[u8] (Transmute); | |
| StorageLive(_39); | |
| _39 = PtrMetadata(copy _36); | |
| StorageLive(_40); | |
| StorageLive(_41); | |
| _41 = PtrMetadata(copy _38); | |
| _40 = Eq(copy _39, move _41); | |
| switchInt(move _40) -> [0: bb24, otherwise: bb23]; | |
| } | |
| bb5: { | |
| StorageDead(_10); | |
| StorageDead(_9); | |
| StorageDead(_8); | |
| StorageDead(_7); | |
| StorageLive(_5); | |
| _23 = const false; | |
| _5 = move ((_2 as Some).0: std::string::String); | |
| _1 = chained_conditions::BacktraceStyle::Full; | |
| drop(_5) -> [return: bb7, unwind: bb22]; | |
| } | |
| bb6: { | |
| StorageDead(_10); | |
| StorageDead(_9); | |
| StorageDead(_8); | |
| StorageDead(_7); | |
| StorageDead(_6); | |
| StorageLive(_13); | |
| _13 = &((_2 as Some).0: std::string::String); | |
| StorageLive(_14); | |
| StorageLive(_15); | |
| StorageLive(_16); | |
| _16 = &(*_13); | |
| _15 = &_16; | |
| StorageLive(_17); | |
| _20 = const chained_conditions::promoted[0]; | |
| _17 = &(*_20); | |
| StorageLive(_47); | |
| StorageLive(_48); | |
| _47 = no_retag copy (*_15); | |
| _48 = no_retag copy (*_17); | |
| StorageLive(_49); | |
| StorageLive(_50); | |
| StorageLive(_51); | |
| StorageLive(_52); | |
| StorageLive(_54); | |
| _54 = copy ((((((*_47).0: std::vec::Vec<u8>).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>); | |
| _52 = copy _54 as *const u8 (Transmute); | |
| StorageDead(_54); | |
| StorageLive(_53); | |
| _53 = copy (((*_47).0: std::vec::Vec<u8>).1: usize); | |
| _51 = *const [u8] from (copy _52, move _53); | |
| StorageDead(_53); | |
| StorageDead(_52); | |
| _50 = &(*_51); | |
| StorageDead(_51); | |
| _49 = copy _50 as &str (Transmute); | |
| StorageDead(_50); | |
| StorageLive(_56); | |
| StorageLive(_58); | |
| _56 = copy _49 as &[u8] (Transmute); | |
| _58 = copy _48 as &[u8] (Transmute); | |
| StorageLive(_59); | |
| _59 = PtrMetadata(copy _56); | |
| StorageLive(_60); | |
| StorageLive(_61); | |
| _61 = PtrMetadata(copy _58); | |
| _60 = Eq(copy _59, move _61); | |
| switchInt(move _60) -> [0: bb28, otherwise: bb27]; | |
| } | |
| bb7: { | |
| StorageDead(_5); | |
| StorageDead(_6); | |
| - goto -> bb19; | |
| + goto -> bb31; | |
| } | |
| bb8: { | |
| StorageDead(_17); | |
| StorageDead(_16); | |
| StorageDead(_15); | |
| StorageDead(_14); | |
| StorageLive(_12); | |
| _23 = const false; | |
| _12 = move ((_2 as Some).0: std::string::String); | |
| _1 = chained_conditions::BacktraceStyle::Off; | |
| drop(_12) -> [return: bb10, unwind: bb22]; | |
| } | |
| bb9: { | |
| StorageDead(_17); | |
| StorageDead(_16); | |
| StorageDead(_15); | |
| StorageDead(_14); | |
| StorageDead(_13); | |
| _1 = chained_conditions::BacktraceStyle::Short; | |
| - goto -> bb19; | |
| + goto -> bb33; | |
| } | |
| bb10: { | |
| StorageDead(_12); | |
| StorageDead(_13); | |
| - goto -> bb19; | |
| + goto -> bb31; | |
| } | |
| bb11: { | |
| _0 = const 3_u8; | |
| goto -> bb14; | |
| } | |
| bb12: { | |
| _0 = const 2_u8; | |
| goto -> bb14; | |
| } | |
| bb13: { | |
| _0 = const 1_u8; | |
| goto -> bb14; | |
| } | |
| bb14: { | |
| StorageDead(_1); | |
| return; | |
| } | |
| bb15 (cleanup): { | |
| resume; | |
| } | |
| bb16: { | |
| _22 = const false; | |
| _23 = const false; | |
| StorageDead(_2); | |
| _19 = discriminant(_1); | |
| switchInt(move _19) -> [0: bb13, 1: bb12, 2: bb11, otherwise: bb2]; | |
| } | |
| bb17: { | |
| switchInt(copy _23) -> [0: bb16, otherwise: bb18]; | |
| } | |
| bb18: { | |
| drop(((_2 as Some).0: std::string::String)) -> [return: bb16, unwind: bb15]; | |
| } | |
| bb19: { | |
| _24 = discriminant(_2); | |
| switchInt(move _24) -> [1: bb17, otherwise: bb16]; | |
| } | |
| bb20 (cleanup): { | |
| switchInt(copy _23) -> [0: bb15, otherwise: bb21]; | |
| } | |
| bb21 (cleanup): { | |
| drop(((_2 as Some).0: std::string::String)) -> [return: bb15, unwind terminate(cleanup)]; | |
| } | |
| bb22 (cleanup): { | |
| _26 = discriminant(_2); | |
| switchInt(move _26) -> [1: bb20, otherwise: bb15]; | |
| } | |
| bb23: { | |
| StorageDead(_41); | |
| StorageLive(_42); | |
| StorageLive(_44); | |
| _44 = &raw const (*_36); | |
| _42 = copy _44 as *const u8 (PtrToPtr); | |
| StorageDead(_44); | |
| StorageLive(_43); | |
| StorageLive(_45); | |
| _45 = &raw const (*_38); | |
| _43 = copy _45 as *const u8 (PtrToPtr); | |
| StorageDead(_45); | |
| StorageLive(_46); | |
| _46 = compare_bytes(move _42, move _43, move _39) -> [return: bb26, unwind unreachable]; | |
| } | |
| bb24: { | |
| StorageDead(_41); | |
| _7 = const false; | |
| - goto -> bb25; | |
| + goto -> bb36; | |
| } | |
| bb25: { | |
| StorageDead(_40); | |
| StorageDead(_39); | |
| StorageDead(_38); | |
| StorageDead(_36); | |
| StorageDead(_29); | |
| StorageDead(_28); | |
| StorageDead(_27); | |
| switchInt(move _7) -> [0: bb6, otherwise: bb5]; | |
| } | |
| bb26: { | |
| _7 = Eq(move _46, const 0_i32); | |
| StorageDead(_46); | |
| StorageDead(_43); | |
| StorageDead(_42); | |
| goto -> bb25; | |
| } | |
| bb27: { | |
| StorageDead(_61); | |
| StorageLive(_62); | |
| StorageLive(_64); | |
| _64 = &raw const (*_56); | |
| _62 = copy _64 as *const u8 (PtrToPtr); | |
| StorageDead(_64); | |
| StorageLive(_63); | |
| StorageLive(_65); | |
| _65 = &raw const (*_58); | |
| _63 = copy _65 as *const u8 (PtrToPtr); | |
| StorageDead(_65); | |
| StorageLive(_66); | |
| _66 = compare_bytes(move _62, move _63, move _59) -> [return: bb30, unwind unreachable]; | |
| } | |
| bb28: { | |
| StorageDead(_61); | |
| _14 = const false; | |
| - goto -> bb29; | |
| + goto -> bb35; | |
| } | |
| bb29: { | |
| StorageDead(_60); | |
| StorageDead(_59); | |
| StorageDead(_58); | |
| StorageDead(_56); | |
| StorageDead(_49); | |
| StorageDead(_48); | |
| StorageDead(_47); | |
| switchInt(move _14) -> [0: bb9, otherwise: bb8]; | |
| } | |
| bb30: { | |
| _14 = Eq(move _66, const 0_i32); | |
| StorageDead(_66); | |
| StorageDead(_63); | |
| StorageDead(_62); | |
| goto -> bb29; | |
| + } | |
| + | |
| + bb31: { | |
| + _24 = discriminant(_2); | |
| + switchInt(move _24) -> [1: bb32, otherwise: bb16]; | |
| + } | |
| + | |
| + bb32: { | |
| + goto -> bb16; | |
| + } | |
| + | |
| + bb33: { | |
| + _24 = discriminant(_2); | |
| + switchInt(move _24) -> [1: bb34, otherwise: bb16]; | |
| + } | |
| + | |
| + bb34: { | |
| + goto -> bb18; | |
| + } | |
| + | |
| + bb35: { | |
| + StorageDead(_60); | |
| + StorageDead(_59); | |
| + StorageDead(_58); | |
| + StorageDead(_56); | |
| + StorageDead(_49); | |
| + StorageDead(_48); | |
| + StorageDead(_47); | |
| + goto -> bb9; | |
| + } | |
| + | |
| + bb36: { | |
| + StorageDead(_40); | |
| + StorageDead(_39); | |
| + StorageDead(_38); | |
| + StorageDead(_36); | |
| + StorageDead(_29); | |
| + StorageDead(_28); | |
| + StorageDead(_27); | |
| + goto -> bb6; | |
| } | |
| } | |