Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 7a37b2b

Browse files
compiler-errorscompiler-errors
committedMar 19, 2024
Fix validation on substituted callee bodies in MIR inliner
1 parent 0cf798e commit 7a37b2b

File tree

6 files changed

+647
-19
lines changed

6 files changed

+647
-19
lines changed
 

‎compiler/rustc_const_eval/src/transform/validate.rs

Lines changed: 15 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -84,7 +84,7 @@ impl<'tcx> MirPass<'tcx> for Validator {
8484
cfg_checker.check_cleanup_control_flow();
8585

8686
// Also run the TypeChecker.
87-
for (location, msg) in validate_types(tcx, self.mir_phase, param_env, body) {
87+
for (location, msg) in validate_types(tcx, self.mir_phase, param_env, body, body) {
8888
cfg_checker.fail(location, msg);
8989
}
9090

@@ -530,19 +530,25 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
530530

531531
/// A faster version of the validation pass that only checks those things which may break when
532532
/// instantiating any generic parameters.
533+
///
534+
/// `caller_body` is used to detect cycles in MIR inlining and MIR validation before
535+
/// `optimized_mir` is available.
533536
pub fn validate_types<'tcx>(
534537
tcx: TyCtxt<'tcx>,
535538
mir_phase: MirPhase,
536539
param_env: ty::ParamEnv<'tcx>,
537540
body: &Body<'tcx>,
541+
caller_body: &Body<'tcx>,
538542
) -> Vec<(Location, String)> {
539-
let mut type_checker = TypeChecker { body, tcx, param_env, mir_phase, failures: Vec::new() };
543+
let mut type_checker =
544+
TypeChecker { body, caller_body, tcx, param_env, mir_phase, failures: Vec::new() };
540545
type_checker.visit_body(body);
541546
type_checker.failures
542547
}
543548

544549
struct TypeChecker<'a, 'tcx> {
545550
body: &'a Body<'tcx>,
551+
caller_body: &'a Body<'tcx>,
546552
tcx: TyCtxt<'tcx>,
547553
param_env: ParamEnv<'tcx>,
548554
mir_phase: MirPhase,
@@ -694,8 +700,13 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
694700
}
695701
&ty::Coroutine(def_id, args) => {
696702
let f_ty = if let Some(var) = parent_ty.variant_index {
697-
let gen_body = if def_id == self.body.source.def_id() {
698-
self.body
703+
// If we're currently validating an inlined copy of this body,
704+
// then it will no longer be parameterized over the original
705+
// args of the coroutine. Otherwise, we prefer to use this body
706+
// since we may be in the process of computing this MIR in the
707+
// first place.
708+
let gen_body = if def_id == self.caller_body.source.def_id() {
709+
self.caller_body
699710
} else {
700711
self.tcx.optimized_mir(def_id)
701712
};

‎compiler/rustc_mir_transform/src/coroutine/by_move_body.rs

Lines changed: 8 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,10 @@ impl<'tcx> MirPass<'tcx> for ByMoveBody {
6464
let mut by_move_body = body.clone();
6565
MakeByMoveBody { tcx, by_ref_fields, by_move_coroutine_ty }.visit_body(&mut by_move_body);
6666
dump_mir(tcx, false, "coroutine_by_move", &0, &by_move_body, |_, _| Ok(()));
67-
by_move_body.source = mir::MirSource {
68-
instance: InstanceDef::CoroutineKindShim {
69-
coroutine_def_id: coroutine_def_id.to_def_id(),
70-
target_kind: ty::ClosureKind::FnOnce,
71-
},
72-
promoted: None,
73-
};
67+
by_move_body.source = mir::MirSource::from_instance(InstanceDef::CoroutineKindShim {
68+
coroutine_def_id: coroutine_def_id.to_def_id(),
69+
target_kind: ty::ClosureKind::FnOnce,
70+
});
7471
body.coroutine.as_mut().unwrap().by_move_body = Some(by_move_body);
7572

7673
// If this is coming from an `AsyncFn` coroutine-closure, we must also create a by-mut body.
@@ -97,13 +94,10 @@ impl<'tcx> MirPass<'tcx> for ByMoveBody {
9794
let mut by_mut_body = body.clone();
9895
by_mut_body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty = by_mut_coroutine_ty;
9996
dump_mir(tcx, false, "coroutine_by_mut", &0, &by_mut_body, |_, _| Ok(()));
100-
by_mut_body.source = mir::MirSource {
101-
instance: InstanceDef::CoroutineKindShim {
102-
coroutine_def_id: coroutine_def_id.to_def_id(),
103-
target_kind: ty::ClosureKind::FnMut,
104-
},
105-
promoted: None,
106-
};
97+
by_mut_body.source = mir::MirSource::from_instance(InstanceDef::CoroutineKindShim {
98+
coroutine_def_id: coroutine_def_id.to_def_id(),
99+
target_kind: ty::ClosureKind::FnMut,
100+
});
107101
body.coroutine.as_mut().unwrap().by_mut_body = Some(by_mut_body);
108102
}
109103
}

‎compiler/rustc_mir_transform/src/inline.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -213,6 +213,7 @@ impl<'tcx> Inliner<'tcx> {
213213
MirPhase::Runtime(RuntimePhase::Optimized),
214214
self.param_env,
215215
&callee_body,
216+
&caller_body,
216217
)
217218
.is_empty()
218219
{

‎tests/mir-opt/inline_coroutine_body.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ pub async fn run(permit: ActionPermit<'_, ()>, ctx: &mut core::task::Context<'_>
88
run2(permit, ctx);
99
}
1010

11-
// EMIT_MIR inline_coroutine_body.run2.Inline.diff
11+
// EMIT_MIR inline_coroutine_body.run2-{closure#0}.Inline.diff
1212
fn run2<T>(permit: ActionPermit<'_, T>, ctx: &mut core::task::Context) {
1313
_ = || {
1414
let mut fut = ActionPermit::perform(permit);

‎tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff

Lines changed: 281 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,281 @@
1+
- // MIR for `run2::{closure#0}` before Inline
2+
+ // MIR for `run2::{closure#0}` after Inline
3+
4+
fn run2::{closure#0}(_1: {closure@$DIR/inline_coroutine_body.rs:13:9: 13:11}) -> () {
5+
debug permit => (_1.0: ActionPermit<'_, T>);
6+
debug ctx => (*(_1.1: &mut std::task::Context<'_>));
7+
let mut _0: ();
8+
let mut _2: {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
9+
let mut _3: ActionPermit<'_, T>;
10+
let mut _5: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
11+
let _6: ();
12+
let mut _7: std::task::Poll<()>;
13+
let mut _8: std::pin::Pin<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>;
14+
let mut _9: &mut std::task::Context<'_>;
15+
let mut _10: &mut std::task::Context<'_>;
16+
scope 1 {
17+
debug fut => _2;
18+
let _4: std::pin::Pin<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>;
19+
scope 2 {
20+
debug fut => _4;
21+
scope 4 {
22+
}
23+
+ scope 7 (inlined ActionPermit::<'_, T>::perform::{closure#0}) {
24+
+ debug _task_context => _31;
25+
+ debug self => ((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})).0: ActionPermit<'_, T>);
26+
+ let _11: ActionPermit<'_, T>;
27+
+ let mut _12: std::future::Ready<()>;
28+
+ let mut _13: std::future::Ready<()>;
29+
+ let mut _14: ();
30+
+ let mut _16: ();
31+
+ let _17: ();
32+
+ let mut _18: std::task::Poll<()>;
33+
+ let mut _19: std::pin::Pin<&mut std::future::Ready<()>>;
34+
+ let mut _20: &mut std::future::Ready<()>;
35+
+ let mut _21: &mut std::future::Ready<()>;
36+
+ let mut _22: &mut std::task::Context<'_>;
37+
+ let mut _23: &mut std::task::Context<'_>;
38+
+ let mut _24: &mut std::task::Context<'_>;
39+
+ let mut _25: isize;
40+
+ let mut _27: !;
41+
+ let mut _28: &mut std::task::Context<'_>;
42+
+ let mut _29: ();
43+
+ let mut _30: ();
44+
+ let mut _31: &mut std::task::Context<'_>;
45+
+ let mut _32: u32;
46+
+ let mut _33: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
47+
+ let mut _34: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
48+
+ let mut _35: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
49+
+ let mut _36: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
50+
+ let mut _37: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
51+
+ let mut _38: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
52+
+ let mut _39: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
53+
+ let mut _40: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
54+
+ scope 8 {
55+
+ debug self => (((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})) as variant#3).0: ActionPermit<'_, T>);
56+
+ let mut _15: std::future::Ready<()>;
57+
+ scope 9 {
58+
+ debug __awaitee => (((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})) as variant#3).1: std::future::Ready<()>);
59+
+ let _26: ();
60+
+ scope 10 {
61+
+ }
62+
+ scope 11 {
63+
+ debug result => _26;
64+
+ }
65+
+ }
66+
+ scope 12 (inlined ready::<()>) {
67+
+ debug t => _14;
68+
+ let mut _41: std::option::Option<()>;
69+
+ }
70+
+ }
71+
+ }
72+
}
73+
scope 3 {
74+
+ scope 6 (inlined Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>::new_unchecked) {
75+
+ debug pointer => _5;
76+
+ }
77+
}
78+
}
79+
+ scope 5 (inlined ActionPermit::<'_, T>::perform) {
80+
+ debug self => _3;
81+
+ }
82+
83+
bb0: {
84+
StorageLive(_2);
85+
StorageLive(_3);
86+
_3 = move (_1.0: ActionPermit<'_, T>);
87+
- _2 = ActionPermit::<'_, T>::perform(move _3) -> [return: bb1, unwind unreachable];
88+
- }
89+
-
90+
- bb1: {
91+
+ _2 = {coroutine@$DIR/inline_coroutine_body.rs:25:28: 27:6 (#0)} { self: move _3 };
92+
StorageDead(_3);
93+
StorageLive(_4);
94+
StorageLive(_5);
95+
_5 = &mut _2;
96+
- _4 = Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>::new_unchecked(move _5) -> [return: bb2, unwind unreachable];
97+
- }
98+
-
99+
- bb2: {
100+
+ _4 = Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}> { __pointer: _5 };
101+
StorageDead(_5);
102+
StorageLive(_6);
103+
StorageLive(_7);
104+
StorageLive(_8);
105+
_8 = move _4;
106+
StorageLive(_9);
107+
_10 = deref_copy (_1.1: &mut std::task::Context<'_>);
108+
_9 = &mut (*_10);
109+
- _7 = <{async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6} as Future>::poll(move _8, move _9) -> [return: bb3, unwind unreachable];
110+
+ StorageLive(_11);
111+
+ StorageLive(_15);
112+
+ StorageLive(_16);
113+
+ StorageLive(_25);
114+
+ StorageLive(_27);
115+
+ StorageLive(_30);
116+
+ StorageLive(_31);
117+
+ StorageLive(_32);
118+
+ StorageLive(_33);
119+
+ StorageLive(_34);
120+
+ StorageLive(_35);
121+
+ StorageLive(_36);
122+
+ StorageLive(_37);
123+
+ StorageLive(_38);
124+
+ StorageLive(_39);
125+
+ StorageLive(_40);
126+
+ _33 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
127+
+ _32 = discriminant((*_33));
128+
+ switchInt(move _32) -> [0: bb3, 1: bb13, 3: bb12, otherwise: bb8];
129+
}
130+
131+
- bb3: {
132+
+ bb1: {
133+
+ StorageDead(_2);
134+
+ return;
135+
+ }
136+
+
137+
+ bb2: {
138+
+ StorageDead(_40);
139+
+ StorageDead(_39);
140+
+ StorageDead(_38);
141+
+ StorageDead(_37);
142+
+ StorageDead(_36);
143+
+ StorageDead(_35);
144+
+ StorageDead(_34);
145+
+ StorageDead(_33);
146+
+ StorageDead(_32);
147+
+ StorageDead(_31);
148+
+ StorageDead(_30);
149+
+ StorageDead(_27);
150+
+ StorageDead(_25);
151+
+ StorageDead(_16);
152+
+ StorageDead(_15);
153+
+ StorageDead(_11);
154+
StorageDead(_9);
155+
StorageDead(_8);
156+
StorageDead(_7);
157+
_6 = const ();
158+
StorageDead(_6);
159+
_0 = const ();
160+
StorageDead(_4);
161+
- drop(_2) -> [return: bb4, unwind unreachable];
162+
+ drop(_2) -> [return: bb1, unwind unreachable];
163+
}
164+
165+
+ bb3: {
166+
+ _31 = move _9;
167+
+ _34 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
168+
+ _35 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
169+
+ (((*_34) as variant#3).0: ActionPermit<'_, T>) = move ((*_35).0: ActionPermit<'_, T>);
170+
+ StorageLive(_12);
171+
+ StorageLive(_13);
172+
+ StorageLive(_14);
173+
+ _14 = ();
174+
+ StorageLive(_41);
175+
+ _41 = Option::<()>::Some(_14);
176+
+ _13 = std::future::Ready::<()>(move _41);
177+
+ StorageDead(_41);
178+
+ StorageDead(_14);
179+
+ _12 = <std::future::Ready<()> as IntoFuture>::into_future(move _13) -> [return: bb4, unwind unreachable];
180+
+ }
181+
+
182+
bb4: {
183+
- StorageDead(_2);
184+
- return;
185+
+ StorageDead(_13);
186+
+ _36 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
187+
+ (((*_36) as variant#3).1: std::future::Ready<()>) = move _12;
188+
+ goto -> bb5;
189+
+ }
190+
+
191+
+ bb5: {
192+
+ StorageLive(_17);
193+
+ StorageLive(_18);
194+
+ StorageLive(_19);
195+
+ StorageLive(_20);
196+
+ StorageLive(_21);
197+
+ _37 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
198+
+ _21 = &mut (((*_37) as variant#3).1: std::future::Ready<()>);
199+
+ _20 = &mut (*_21);
200+
+ _19 = Pin::<&mut std::future::Ready<()>>::new_unchecked(move _20) -> [return: bb6, unwind unreachable];
201+
+ }
202+
+
203+
+ bb6: {
204+
+ StorageDead(_20);
205+
+ StorageLive(_22);
206+
+ StorageLive(_23);
207+
+ StorageLive(_24);
208+
+ _24 = _31;
209+
+ _23 = move _24;
210+
+ _22 = &mut (*_23);
211+
+ StorageDead(_24);
212+
+ _18 = <std::future::Ready<()> as Future>::poll(move _19, move _22) -> [return: bb7, unwind unreachable];
213+
+ }
214+
+
215+
+ bb7: {
216+
+ StorageDead(_22);
217+
+ StorageDead(_19);
218+
+ _25 = discriminant(_18);
219+
+ switchInt(move _25) -> [0: bb10, 1: bb9, otherwise: bb8];
220+
+ }
221+
+
222+
+ bb8: {
223+
+ unreachable;
224+
+ }
225+
+
226+
+ bb9: {
227+
+ _17 = const ();
228+
+ StorageDead(_23);
229+
+ StorageDead(_21);
230+
+ StorageDead(_18);
231+
+ StorageDead(_17);
232+
+ StorageLive(_28);
233+
+ StorageLive(_29);
234+
+ _29 = ();
235+
+ _7 = Poll::<()>::Pending;
236+
+ StorageDead(_12);
237+
+ StorageDead(_28);
238+
+ StorageDead(_29);
239+
+ _38 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
240+
+ discriminant((*_38)) = 3;
241+
+ goto -> bb2;
242+
+ }
243+
+
244+
+ bb10: {
245+
+ StorageLive(_26);
246+
+ _26 = ((_18 as Ready).0: ());
247+
+ _30 = _26;
248+
+ StorageDead(_26);
249+
+ StorageDead(_23);
250+
+ StorageDead(_21);
251+
+ StorageDead(_18);
252+
+ StorageDead(_17);
253+
+ StorageDead(_12);
254+
+ _39 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
255+
+ drop((((*_39) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb11, unwind unreachable];
256+
+ }
257+
+
258+
+ bb11: {
259+
+ _7 = Poll::<()>::Ready(move _30);
260+
+ _40 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
261+
+ discriminant((*_40)) = 1;
262+
+ goto -> bb2;
263+
+ }
264+
+
265+
+ bb12: {
266+
+ StorageLive(_12);
267+
+ StorageLive(_28);
268+
+ StorageLive(_29);
269+
+ _28 = move _9;
270+
+ StorageDead(_29);
271+
+ _31 = move _28;
272+
+ StorageDead(_28);
273+
+ _16 = const ();
274+
+ goto -> bb5;
275+
+ }
276+
+
277+
+ bb13: {
278+
+ assert(const false, "`async fn` resumed after completion") -> [success: bb13, unwind unreachable];
279+
}
280+
}
281+

‎tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff

Lines changed: 341 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,341 @@
1+
- // MIR for `run2::{closure#0}` before Inline
2+
+ // MIR for `run2::{closure#0}` after Inline
3+
4+
fn run2::{closure#0}(_1: {closure@$DIR/inline_coroutine_body.rs:13:9: 13:11}) -> () {
5+
debug permit => (_1.0: ActionPermit<'_, T>);
6+
debug ctx => (*(_1.1: &mut std::task::Context<'_>));
7+
let mut _0: ();
8+
let mut _2: {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
9+
let mut _3: ActionPermit<'_, T>;
10+
let mut _5: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
11+
let _6: ();
12+
let mut _7: std::task::Poll<()>;
13+
let mut _8: std::pin::Pin<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>;
14+
let mut _9: &mut std::task::Context<'_>;
15+
let mut _10: &mut std::task::Context<'_>;
16+
scope 1 {
17+
debug fut => _2;
18+
let _4: std::pin::Pin<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>;
19+
scope 2 {
20+
debug fut => _4;
21+
scope 4 {
22+
}
23+
+ scope 7 (inlined ActionPermit::<'_, T>::perform::{closure#0}) {
24+
+ debug _task_context => _31;
25+
+ debug self => ((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})).0: ActionPermit<'_, T>);
26+
+ let _11: ActionPermit<'_, T>;
27+
+ let mut _12: std::future::Ready<()>;
28+
+ let mut _13: std::future::Ready<()>;
29+
+ let mut _14: ();
30+
+ let mut _16: ();
31+
+ let _17: ();
32+
+ let mut _18: std::task::Poll<()>;
33+
+ let mut _19: std::pin::Pin<&mut std::future::Ready<()>>;
34+
+ let mut _20: &mut std::future::Ready<()>;
35+
+ let mut _21: &mut std::future::Ready<()>;
36+
+ let mut _22: &mut std::task::Context<'_>;
37+
+ let mut _23: &mut std::task::Context<'_>;
38+
+ let mut _24: &mut std::task::Context<'_>;
39+
+ let mut _25: isize;
40+
+ let mut _27: !;
41+
+ let mut _28: &mut std::task::Context<'_>;
42+
+ let mut _29: ();
43+
+ let mut _30: ();
44+
+ let mut _31: &mut std::task::Context<'_>;
45+
+ let mut _32: u32;
46+
+ let mut _33: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
47+
+ let mut _34: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
48+
+ let mut _35: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
49+
+ let mut _36: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
50+
+ let mut _37: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
51+
+ let mut _38: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
52+
+ let mut _39: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
53+
+ let mut _40: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
54+
+ let mut _41: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
55+
+ let mut _42: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6};
56+
+ scope 8 {
57+
+ debug self => (((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})) as variant#3).0: ActionPermit<'_, T>);
58+
+ let mut _15: std::future::Ready<()>;
59+
+ scope 9 {
60+
+ debug __awaitee => (((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})) as variant#3).1: std::future::Ready<()>);
61+
+ let _26: ();
62+
+ scope 10 {
63+
+ }
64+
+ scope 11 {
65+
+ debug result => _26;
66+
+ }
67+
+ }
68+
+ scope 12 (inlined ready::<()>) {
69+
+ debug t => _14;
70+
+ let mut _43: std::option::Option<()>;
71+
+ }
72+
+ }
73+
+ }
74+
}
75+
scope 3 {
76+
+ scope 6 (inlined Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>::new_unchecked) {
77+
+ debug pointer => _5;
78+
+ }
79+
}
80+
}
81+
+ scope 5 (inlined ActionPermit::<'_, T>::perform) {
82+
+ debug self => _3;
83+
+ }
84+
85+
bb0: {
86+
StorageLive(_2);
87+
StorageLive(_3);
88+
_3 = move (_1.0: ActionPermit<'_, T>);
89+
- _2 = ActionPermit::<'_, T>::perform(move _3) -> [return: bb1, unwind: bb6];
90+
- }
91+
-
92+
- bb1: {
93+
+ _2 = {coroutine@$DIR/inline_coroutine_body.rs:25:28: 27:6 (#0)} { self: move _3 };
94+
StorageDead(_3);
95+
StorageLive(_4);
96+
StorageLive(_5);
97+
_5 = &mut _2;
98+
- _4 = Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>::new_unchecked(move _5) -> [return: bb2, unwind: bb5];
99+
- }
100+
-
101+
- bb2: {
102+
+ _4 = Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}> { __pointer: _5 };
103+
StorageDead(_5);
104+
StorageLive(_6);
105+
StorageLive(_7);
106+
StorageLive(_8);
107+
_8 = move _4;
108+
StorageLive(_9);
109+
_10 = deref_copy (_1.1: &mut std::task::Context<'_>);
110+
_9 = &mut (*_10);
111+
- _7 = <{async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6} as Future>::poll(move _8, move _9) -> [return: bb3, unwind: bb5];
112+
+ StorageLive(_11);
113+
+ StorageLive(_15);
114+
+ StorageLive(_16);
115+
+ StorageLive(_25);
116+
+ StorageLive(_27);
117+
+ StorageLive(_30);
118+
+ StorageLive(_31);
119+
+ StorageLive(_32);
120+
+ StorageLive(_33);
121+
+ StorageLive(_34);
122+
+ StorageLive(_35);
123+
+ StorageLive(_36);
124+
+ StorageLive(_37);
125+
+ StorageLive(_38);
126+
+ StorageLive(_39);
127+
+ StorageLive(_40);
128+
+ StorageLive(_41);
129+
+ StorageLive(_42);
130+
+ _33 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
131+
+ _32 = discriminant((*_33));
132+
+ switchInt(move _32) -> [0: bb5, 1: bb22, 2: bb21, 3: bb20, otherwise: bb10];
133+
}
134+
135+
- bb3: {
136+
+ bb1: {
137+
+ StorageDead(_2);
138+
+ return;
139+
+ }
140+
+
141+
+ bb2 (cleanup): {
142+
+ drop(_2) -> [return: bb3, unwind terminate(cleanup)];
143+
+ }
144+
+
145+
+ bb3 (cleanup): {
146+
+ resume;
147+
+ }
148+
+
149+
+ bb4: {
150+
+ StorageDead(_42);
151+
+ StorageDead(_41);
152+
+ StorageDead(_40);
153+
+ StorageDead(_39);
154+
+ StorageDead(_38);
155+
+ StorageDead(_37);
156+
+ StorageDead(_36);
157+
+ StorageDead(_35);
158+
+ StorageDead(_34);
159+
+ StorageDead(_33);
160+
+ StorageDead(_32);
161+
+ StorageDead(_31);
162+
+ StorageDead(_30);
163+
+ StorageDead(_27);
164+
+ StorageDead(_25);
165+
+ StorageDead(_16);
166+
+ StorageDead(_15);
167+
+ StorageDead(_11);
168+
StorageDead(_9);
169+
StorageDead(_8);
170+
StorageDead(_7);
171+
_6 = const ();
172+
StorageDead(_6);
173+
_0 = const ();
174+
StorageDead(_4);
175+
- drop(_2) -> [return: bb4, unwind: bb6];
176+
+ drop(_2) -> [return: bb1, unwind: bb3];
177+
}
178+
179+
- bb4: {
180+
- StorageDead(_2);
181+
- return;
182+
+ bb5: {
183+
+ _31 = move _9;
184+
+ _34 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
185+
+ _35 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
186+
+ (((*_34) as variant#3).0: ActionPermit<'_, T>) = move ((*_35).0: ActionPermit<'_, T>);
187+
+ StorageLive(_12);
188+
+ StorageLive(_13);
189+
+ StorageLive(_14);
190+
+ _14 = ();
191+
+ StorageLive(_43);
192+
+ _43 = Option::<()>::Some(_14);
193+
+ _13 = std::future::Ready::<()>(move _43);
194+
+ StorageDead(_43);
195+
+ StorageDead(_14);
196+
+ _12 = <std::future::Ready<()> as IntoFuture>::into_future(move _13) -> [return: bb6, unwind: bb17];
197+
}
198+
199+
- bb5 (cleanup): {
200+
- drop(_2) -> [return: bb6, unwind terminate(cleanup)];
201+
+ bb6: {
202+
+ StorageDead(_13);
203+
+ _36 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
204+
+ (((*_36) as variant#3).1: std::future::Ready<()>) = move _12;
205+
+ goto -> bb7;
206+
}
207+
208+
- bb6 (cleanup): {
209+
- resume;
210+
+ bb7: {
211+
+ StorageLive(_17);
212+
+ StorageLive(_18);
213+
+ StorageLive(_19);
214+
+ StorageLive(_20);
215+
+ StorageLive(_21);
216+
+ _37 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
217+
+ _21 = &mut (((*_37) as variant#3).1: std::future::Ready<()>);
218+
+ _20 = &mut (*_21);
219+
+ _19 = Pin::<&mut std::future::Ready<()>>::new_unchecked(move _20) -> [return: bb8, unwind: bb15];
220+
+ }
221+
+
222+
+ bb8: {
223+
+ StorageDead(_20);
224+
+ StorageLive(_22);
225+
+ StorageLive(_23);
226+
+ StorageLive(_24);
227+
+ _24 = _31;
228+
+ _23 = move _24;
229+
+ _22 = &mut (*_23);
230+
+ StorageDead(_24);
231+
+ _18 = <std::future::Ready<()> as Future>::poll(move _19, move _22) -> [return: bb9, unwind: bb14];
232+
+ }
233+
+
234+
+ bb9: {
235+
+ StorageDead(_22);
236+
+ StorageDead(_19);
237+
+ _25 = discriminant(_18);
238+
+ switchInt(move _25) -> [0: bb12, 1: bb11, otherwise: bb10];
239+
+ }
240+
+
241+
+ bb10: {
242+
+ unreachable;
243+
+ }
244+
+
245+
+ bb11: {
246+
+ _17 = const ();
247+
+ StorageDead(_23);
248+
+ StorageDead(_21);
249+
+ StorageDead(_18);
250+
+ StorageDead(_17);
251+
+ StorageLive(_28);
252+
+ StorageLive(_29);
253+
+ _29 = ();
254+
+ _7 = Poll::<()>::Pending;
255+
+ StorageDead(_12);
256+
+ StorageDead(_28);
257+
+ StorageDead(_29);
258+
+ _38 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
259+
+ discriminant((*_38)) = 3;
260+
+ goto -> bb4;
261+
+ }
262+
+
263+
+ bb12: {
264+
+ StorageLive(_26);
265+
+ _26 = ((_18 as Ready).0: ());
266+
+ _30 = _26;
267+
+ StorageDead(_26);
268+
+ StorageDead(_23);
269+
+ StorageDead(_21);
270+
+ StorageDead(_18);
271+
+ StorageDead(_17);
272+
+ StorageDead(_12);
273+
+ _39 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
274+
+ drop((((*_39) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb13, unwind: bb19];
275+
+ }
276+
+
277+
+ bb13: {
278+
+ _7 = Poll::<()>::Ready(move _30);
279+
+ _40 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
280+
+ discriminant((*_40)) = 1;
281+
+ goto -> bb4;
282+
+ }
283+
+
284+
+ bb14 (cleanup): {
285+
+ StorageDead(_22);
286+
+ StorageDead(_19);
287+
+ StorageDead(_23);
288+
+ goto -> bb16;
289+
+ }
290+
+
291+
+ bb15 (cleanup): {
292+
+ StorageDead(_20);
293+
+ StorageDead(_19);
294+
+ goto -> bb16;
295+
+ }
296+
+
297+
+ bb16 (cleanup): {
298+
+ StorageDead(_21);
299+
+ StorageDead(_18);
300+
+ StorageDead(_17);
301+
+ goto -> bb18;
302+
+ }
303+
+
304+
+ bb17 (cleanup): {
305+
+ StorageDead(_13);
306+
+ goto -> bb18;
307+
+ }
308+
+
309+
+ bb18 (cleanup): {
310+
+ StorageDead(_12);
311+
+ _41 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
312+
+ drop((((*_41) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb19, unwind terminate(cleanup)];
313+
+ }
314+
+
315+
+ bb19 (cleanup): {
316+
+ _42 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6});
317+
+ discriminant((*_42)) = 2;
318+
+ goto -> bb2;
319+
+ }
320+
+
321+
+ bb20: {
322+
+ StorageLive(_12);
323+
+ StorageLive(_28);
324+
+ StorageLive(_29);
325+
+ _28 = move _9;
326+
+ StorageDead(_29);
327+
+ _31 = move _28;
328+
+ StorageDead(_28);
329+
+ _16 = const ();
330+
+ goto -> bb7;
331+
+ }
332+
+
333+
+ bb21: {
334+
+ assert(const false, "`async fn` resumed after panicking") -> [success: bb21, unwind: bb2];
335+
+ }
336+
+
337+
+ bb22: {
338+
+ assert(const false, "`async fn` resumed after completion") -> [success: bb22, unwind: bb2];
339+
}
340+
}
341+

0 commit comments

Comments
 (0)
Please sign in to comment.