| 
11 | 11 |       let _9: ();  | 
12 | 12 |       let _10: ();  | 
13 | 13 |       let mut _11: std::fmt::Arguments<'_>;  | 
14 |  | -      let mut _12: &[&str];  | 
15 |  | -      let mut _13: &[&str; 3];  | 
16 |  | -      let _14: &[&str; 3];  | 
17 |  | -      let _15: [&str; 3];  | 
18 |  | -      let mut _16: &[core::fmt::rt::Argument<'_>];  | 
19 |  | -      let mut _17: &[core::fmt::rt::Argument<'_>; 2];  | 
20 |  | -      let _18: &[core::fmt::rt::Argument<'_>; 2];  | 
21 |  | -      let _19: [core::fmt::rt::Argument<'_>; 2];  | 
22 |  | -      let mut _20: core::fmt::rt::Argument<'_>;  | 
23 |  | -      let mut _21: &std::boxed::Box<dyn std::fmt::Display>;  | 
24 |  | -      let _22: &std::boxed::Box<dyn std::fmt::Display>;  | 
25 |  | -      let mut _23: core::fmt::rt::Argument<'_>;  | 
26 |  | -      let mut _24: &u32;  | 
27 |  | -      let _25: &u32;  | 
28 |  | -      let mut _27: bool;  | 
 | 14 | +      let mut _12: &[&str; 3];  | 
 | 15 | +      let _13: &[&str; 3];  | 
 | 16 | +      let _14: [&str; 3];  | 
 | 17 | +      let mut _15: &[core::fmt::rt::Argument<'_>; 2];  | 
 | 18 | +      let _16: &[core::fmt::rt::Argument<'_>; 2];  | 
 | 19 | +      let _17: [core::fmt::rt::Argument<'_>; 2];  | 
 | 20 | +      let mut _18: core::fmt::rt::Argument<'_>;  | 
 | 21 | +      let mut _19: &std::boxed::Box<dyn std::fmt::Display>;  | 
 | 22 | +      let _20: &std::boxed::Box<dyn std::fmt::Display>;  | 
 | 23 | +      let mut _21: core::fmt::rt::Argument<'_>;  | 
 | 24 | +      let mut _22: &u32;  | 
 | 25 | +      let _23: &u32;  | 
 | 26 | +      let mut _25: bool;  | 
 | 27 | +      let mut _26: isize;  | 
 | 28 | +      let mut _27: isize;  | 
29 | 29 |       let mut _28: isize;  | 
30 |  | -      let mut _29: isize;  | 
31 |  | -      let mut _30: isize;  | 
32 |  | -+     let _31: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>;  | 
33 |  | -+     let _32: u32;  | 
 | 30 | ++     let _29: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>;  | 
 | 31 | ++     let _30: u32;  | 
34 | 32 |       scope 1 {  | 
35 | 33 | -         debug foo => _1;  | 
36 |  | -+         debug ((foo: Foo<T>).0: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>) => _31;  | 
37 |  | -+         debug ((foo: Foo<T>).1: u32) => _32;  | 
 | 34 | ++         debug ((foo: Foo<T>).0: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>) => _29;  | 
 | 35 | ++         debug ((foo: Foo<T>).1: u32) => _30;  | 
38 | 36 |           let _5: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>;  | 
39 | 37 |           scope 2 {  | 
40 | 38 |               debug x => _5;  | 
 | 
44 | 42 |                   scope 4 {  | 
45 | 43 |                       debug x => _8;  | 
46 | 44 |                       let _8: std::boxed::Box<dyn std::fmt::Display>;  | 
47 |  | -                      let mut _26: &[&str; 3];  | 
 | 45 | +                      let mut _24: &[&str; 3];  | 
48 | 46 |                   }  | 
49 | 47 |               }  | 
50 | 48 |           }  | 
51 | 49 |       }  | 
52 | 50 | 
 
  | 
53 | 51 |       bb0: {  | 
54 |  | -          _27 = const false;  | 
 | 52 | +          _25 = const false;  | 
55 | 53 | -         StorageLive(_1);  | 
56 |  | -+         StorageLive(_31);  | 
57 |  | -+         StorageLive(_32);  | 
 | 54 | ++         StorageLive(_29);  | 
 | 55 | ++         StorageLive(_30);  | 
58 | 56 | +         nop;  | 
59 | 57 |           StorageLive(_2);  | 
60 | 58 |           StorageLive(_3);  | 
 | 
68 | 66 |           _2 = Result::<Box<dyn std::fmt::Display>, <T as Err>::Err>::Ok(move _3);  | 
69 | 67 |           StorageDead(_3);  | 
70 | 68 | -         _1 = Foo::<T> { x: move _2, y: const 7_u32 };  | 
71 |  | -+         _31 = move _2;  | 
72 |  | -+         _32 = const 7_u32;  | 
 | 69 | ++         _29 = move _2;  | 
 | 70 | ++         _30 = const 7_u32;  | 
73 | 71 | +         nop;  | 
74 | 72 |           StorageDead(_2);  | 
75 | 73 |           StorageLive(_5);  | 
76 |  | -          _27 = const true;  | 
 | 74 | +          _25 = const true;  | 
77 | 75 | -         _5 = move (_1.0: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>);  | 
78 |  | -+         _5 = move _31;  | 
 | 76 | ++         _5 = move _29;  | 
79 | 77 |           StorageLive(_6);  | 
80 | 78 | -         _6 = (_1.1: u32);  | 
81 |  | -+         _6 = _32;  | 
 | 79 | ++         _6 = _30;  | 
82 | 80 |           _7 = discriminant(_5);  | 
83 | 81 |           switchInt(move _7) -> [0: bb2, otherwise: bb7];  | 
84 | 82 |       }  | 
85 | 83 | 
 
  | 
86 | 84 |       bb2: {  | 
87 | 85 |           StorageLive(_8);  | 
88 |  | -          _27 = const false;  | 
 | 86 | +          _25 = const false;  | 
89 | 87 |           _8 = move ((_5 as Ok).0: std::boxed::Box<dyn std::fmt::Display>);  | 
90 | 88 |           StorageLive(_9);  | 
91 | 89 |           StorageLive(_10);  | 
92 | 90 |           StorageLive(_11);  | 
93 | 91 |           StorageLive(_12);  | 
94 | 92 |           StorageLive(_13);  | 
95 |  | -          StorageLive(_14);  | 
96 |  | -          _26 = const foo::<T>::promoted[0];  | 
97 |  | -          _14 = &(*_26);  | 
98 |  | -          _13 = &(*_14);  | 
99 |  | -          _12 = move _13 as &[&str] (PointerCoercion(Unsize));  | 
100 |  | -          StorageDead(_13);  | 
 | 93 | +          _24 = const foo::<T>::promoted[0];  | 
 | 94 | +          _13 = &(*_24);  | 
 | 95 | +          _12 = &(*_13);  | 
 | 96 | +          StorageLive(_15);  | 
101 | 97 |           StorageLive(_16);  | 
102 | 98 |           StorageLive(_17);  | 
103 | 99 |           StorageLive(_18);  | 
104 | 100 |           StorageLive(_19);  | 
105 | 101 |           StorageLive(_20);  | 
106 |  | -          StorageLive(_21);  | 
107 |  | -          StorageLive(_22);  | 
108 |  | -          _22 = &_8;  | 
109 |  | -          _21 = &(*_22);  | 
110 |  | -          _20 = core::fmt::rt::Argument::<'_>::new_display::<Box<dyn std::fmt::Display>>(move _21) -> [return: bb3, unwind unreachable];  | 
 | 102 | +          _20 = &_8;  | 
 | 103 | +          _19 = &(*_20);  | 
 | 104 | +          _18 = core::fmt::rt::Argument::<'_>::new_display::<Box<dyn std::fmt::Display>>(move _19) -> [return: bb3, unwind unreachable];  | 
111 | 105 |       }  | 
112 | 106 | 
 
  | 
113 | 107 |       bb3: {  | 
114 |  | -          StorageDead(_21);  | 
 | 108 | +          StorageDead(_19);  | 
 | 109 | +          StorageLive(_21);  | 
 | 110 | +          StorageLive(_22);  | 
115 | 111 |           StorageLive(_23);  | 
116 |  | -          StorageLive(_24);  | 
117 |  | -          StorageLive(_25);  | 
118 |  | -          _25 = &_6;  | 
119 |  | -          _24 = &(*_25);  | 
120 |  | -          _23 = core::fmt::rt::Argument::<'_>::new_display::<u32>(move _24) -> [return: bb4, unwind unreachable];  | 
 | 112 | +          _23 = &_6;  | 
 | 113 | +          _22 = &(*_23);  | 
 | 114 | +          _21 = core::fmt::rt::Argument::<'_>::new_display::<u32>(move _22) -> [return: bb4, unwind unreachable];  | 
121 | 115 |       }  | 
122 | 116 | 
 
  | 
123 | 117 |       bb4: {  | 
124 |  | -          StorageDead(_24);  | 
125 |  | -          _19 = [move _20, move _23];  | 
126 |  | -          StorageDead(_23);  | 
127 |  | -          StorageDead(_20);  | 
128 |  | -          _18 = &_19;  | 
129 |  | -          _17 = &(*_18);  | 
130 |  | -          _16 = move _17 as &[core::fmt::rt::Argument<'_>] (PointerCoercion(Unsize));  | 
131 |  | -          StorageDead(_17);  | 
132 |  | -          _11 = Arguments::<'_>::new_v1(move _12, move _16) -> [return: bb5, unwind unreachable];  | 
 | 118 | +          StorageDead(_22);  | 
 | 119 | +          _17 = [move _18, move _21];  | 
 | 120 | +          StorageDead(_21);  | 
 | 121 | +          StorageDead(_18);  | 
 | 122 | +          _16 = &_17;  | 
 | 123 | +          _15 = &(*_16);  | 
 | 124 | +          _11 = Arguments::<'_>::new_v1::<3, 2>(move _12, move _15) -> [return: bb5, unwind unreachable];  | 
133 | 125 |       }  | 
134 | 126 | 
 
  | 
135 | 127 |       bb5: {  | 
136 |  | -          StorageDead(_16);  | 
 | 128 | +          StorageDead(_15);  | 
137 | 129 |           StorageDead(_12);  | 
138 | 130 |           _10 = _eprint(move _11) -> [return: bb6, unwind unreachable];  | 
139 | 131 |       }  | 
140 | 132 | 
 
  | 
141 | 133 |       bb6: {  | 
142 | 134 |           StorageDead(_11);  | 
143 |  | -          StorageDead(_25);  | 
144 |  | -          StorageDead(_22);  | 
145 |  | -          StorageDead(_19);  | 
146 |  | -          StorageDead(_18);  | 
147 |  | -          StorageDead(_14);  | 
 | 135 | +          StorageDead(_23);  | 
 | 136 | +          StorageDead(_20);  | 
 | 137 | +          StorageDead(_17);  | 
 | 138 | +          StorageDead(_16);  | 
 | 139 | +          StorageDead(_13);  | 
148 | 140 |           StorageDead(_10);  | 
149 | 141 |           _9 = const ();  | 
150 | 142 |           StorageDead(_9);  | 
 | 
164 | 156 | 
 
  | 
165 | 157 |       bb9: {  | 
166 | 158 |           StorageDead(_6);  | 
167 |  | -          _28 = discriminant(_5);  | 
168 |  | -          switchInt(move _28) -> [0: bb11, otherwise: bb13];  | 
 | 159 | +          _26 = discriminant(_5);  | 
 | 160 | +          switchInt(move _26) -> [0: bb11, otherwise: bb13];  | 
169 | 161 |       }  | 
170 | 162 | 
 
  | 
171 | 163 |       bb10: {  | 
172 |  | -          _27 = const false;  | 
 | 164 | +          _25 = const false;  | 
173 | 165 |           StorageDead(_5);  | 
174 | 166 | -         StorageDead(_1);  | 
175 |  | -+         StorageDead(_31);  | 
176 |  | -+         StorageDead(_32);  | 
 | 167 | ++         StorageDead(_29);  | 
 | 168 | ++         StorageDead(_30);  | 
177 | 169 | +         nop;  | 
178 | 170 |           return;  | 
179 | 171 |       }  | 
180 | 172 | 
 
  | 
181 | 173 |       bb11: {  | 
182 |  | -          switchInt(_27) -> [0: bb10, otherwise: bb12];  | 
 | 174 | +          switchInt(_25) -> [0: bb10, otherwise: bb12];  | 
183 | 175 |       }  | 
184 | 176 | 
 
  | 
185 | 177 |       bb12: {  | 
 | 
0 commit comments