rust/tests/mir-opt/funky_arms.float_to_exponential_common.ConstProp.panic-abort.diff

- // 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) -> Result<(), std::fmt::Error> {
      debug fmt => _1;
      debug num => _2;
      debug upper => _3;
      let mut _0: std::result::Result<(), std::fmt::Error>;
      let _4: bool;
      let mut _6: std::option::Option<usize>;
      let mut _7: isize;
      let mut _9: core::num::flt2dec::Sign;
      let mut _10: u32;
      let mut _11: u32;
      let mut _12: core::num::flt2dec::Sign;
      scope 1 {
          debug force_sign => _4;
          let _5: core::num::flt2dec::Sign;
          scope 2 {
              debug sign => _5;
              scope 3 {
                  debug precision => _8;
                  let _8: usize;
                  scope 5 (inlined Formatter::<'_>::precision) {
                      debug self => _1;
                  }
              }
          }
      }
      scope 4 (inlined Formatter::<'_>::sign_plus) {
          debug self => _1;
          let mut _13: u32;
          let mut _14: u32;
      }
  
      bb0: {
          StorageLive(_4);
          StorageLive(_13);
          StorageLive(_14);
          _14 = ((*_1).0: u32);
          _13 = BitAnd(move _14, const 1_u32);
          StorageDead(_14);
          _4 = Ne(move _13, const 0_u32);
          StorageDead(_13);
          StorageLive(_5);
          switchInt(_4) -> [0: bb2, otherwise: bb1];
      }
  
      bb1: {
          _5 = const MinusPlus;
          goto -> bb3;
      }
  
      bb2: {
          _5 = const Minus;
          goto -> bb3;
      }
  
      bb3: {
          StorageLive(_6);
          _6 = ((*_1).4: std::option::Option<usize>);
          _7 = discriminant(_6);
          switchInt(move _7) -> [1: bb4, otherwise: bb6];
      }
  
      bb4: {
          _8 = ((_6 as Some).0: usize);
          StorageLive(_9);
          _9 = _5;
          StorageLive(_10);
          StorageLive(_11);
          _11 = _8 as u32 (IntToInt);
          _10 = Add(move _11, const 1_u32);
          StorageDead(_11);
          _0 = float_to_exponential_common_exact::<T>(_1, _2, move _9, move _10, _3) -> [return: bb5, unwind unreachable];
      }
  
      bb5: {
          StorageDead(_10);
          StorageDead(_9);
          goto -> bb8;
      }
  
      bb6: {
          StorageLive(_12);
          _12 = _5;
          _0 = float_to_exponential_common_shortest::<T>(_1, _2, move _12, _3) -> [return: bb7, unwind unreachable];
      }
  
      bb7: {
          StorageDead(_12);
          goto -> bb8;
      }
  
      bb8: {
          StorageDead(_5);
          StorageDead(_4);
          StorageDead(_6);
          return;
      }
  }