| - // 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 = copy (*_8); |
| _28 = 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); |
| StorageLive(_39); |
| StorageLive(_42); |
| StorageLive(_43); |
| _36 = copy _29 as &[u8] (Transmute); |
| _38 = copy _28 as &[u8] (Transmute); |
| _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 = copy (*_15); |
| _48 = 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); |
| StorageLive(_59); |
| StorageLive(_62); |
| StorageLive(_63); |
| _56 = copy _49 as &[u8] (Transmute); |
| _58 = copy _48 as &[u8] (Transmute); |
| _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(_44); |
| _44 = &raw const (*_36); |
| _42 = copy _44 as *const u8 (PtrToPtr); |
| StorageDead(_44); |
| 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(_43); |
| StorageDead(_42); |
| 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); |
| goto -> bb25; |
| } |
| |
| bb27: { |
| StorageDead(_61); |
| StorageLive(_64); |
| _64 = &raw const (*_56); |
| _62 = copy _64 as *const u8 (PtrToPtr); |
| StorageDead(_64); |
| 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(_63); |
| StorageDead(_62); |
| 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); |
| 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(_63); |
| + StorageDead(_62); |
| + StorageDead(_59); |
| + StorageDead(_58); |
| + StorageDead(_56); |
| + StorageDead(_49); |
| + StorageDead(_48); |
| + StorageDead(_47); |
| + goto -> bb9; |
| + } |
| + |
| + bb36: { |
| + StorageDead(_40); |
| + StorageDead(_43); |
| + StorageDead(_42); |
| + StorageDead(_39); |
| + StorageDead(_38); |
| + StorageDead(_36); |
| + StorageDead(_29); |
| + StorageDead(_28); |
| + StorageDead(_27); |
| + goto -> bb6; |
| } |
| } |
| |
