Change:
<ins> - // MIR for `run2::{closure#0}` before Inline + // MIR for `run2::{closure#0}` after Inline fn run2::{closure#0}(_1: {closure@$DIR/inline_coroutine_body.rs:13:9: 13:11}) -> () { debug permit => (_1.0: ActionPermit<'_, T>); debug ctx => (*(_1.1: &mut std::task::Context<'_>)); let mut _0: (); let mut _2: {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; let mut _3: ActionPermit<'_, T>; let mut _5: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; let _6: (); let mut _7: std::task::Poll<()>; let mut _8: std::pin::Pin<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>; let mut _9: &mut std::task::Context<'_>; let mut _10: &mut std::task::Context<'_>; scope 1 { debug fut => _2; let _4: std::pin::Pin<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>; scope 2 { debug fut => _4; scope 4 { } +             scope 7 (inlined ActionPermit::<'_, T>::perform::{closure#0}) { +                 debug _task_context => _31; +                 debug self => ((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})).0: ActionPermit<'_, T>); +                 let _11: ActionPermit<'_, T>; +                 let mut _12: std::future::Ready<()>; +                 let mut _13: std::future::Ready<()>; +                 let mut _14: (); +                 let mut _16: (); +                 let _17: (); +                 let mut _18: std::task::Poll<()>; +                 let mut _19: std::pin::Pin<&mut std::future::Ready<()>>; +                 let mut _20: &mut std::future::Ready<()>; +                 let mut _21: &mut std::future::Ready<()>; +                 let mut _22: &mut std::task::Context<'_>; +                 let mut _23: &mut std::task::Context<'_>; +                 let mut _24: &mut std::task::Context<'_>; +                 let mut _25: isize; +                 let mut _27: !; +                 let mut _28: &mut std::task::Context<'_>; +                 let mut _29: (); +                 let mut _30: (); +                 let mut _31: &mut std::task::Context<'_>; +                 let mut _32: u32; +                 let mut _33: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _34: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _35: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _36: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _37: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _38: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _39: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _40: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _41: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 let mut _42: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}; +                 scope 8 { +                     debug self => (((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})) as variant#3).0: ActionPermit<'_, T>); +                     let mut _15: std::future::Ready<()>; +                     scope 9 { +                         debug __awaitee => (((*(_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6})) as variant#3).1: std::future::Ready<()>); +                         let _26: (); +                         scope 10 { +                         } +                         scope 11 { +                             debug result => _26; +                         } +                     } +                     scope 12 (inlined ready::<()>) { +                         debug t => _14; +                         let mut _43: std::option::Option<()>; +                     } +                 } +             } } scope 3 { +             scope 6 (inlined Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>::new_unchecked) { +                 debug pointer => _5; +             } } } +     scope 5 (inlined ActionPermit::<'_, T>::perform) { +         debug self => _3; +     } bb0: { StorageLive(_2); StorageLive(_3); _3 = move (_1.0: ActionPermit<'_, T>); -         _2 = ActionPermit::<'_, T>::perform(move _3) -> [return: bb1, unwind: bb6]; -     } - -     bb1: { +         _2 = {coroutine@$DIR/inline_coroutine_body.rs:25:28: 27:6 (#0)} { self: move _3 }; StorageDead(_3); StorageLive(_4); StorageLive(_5); _5 = &mut _2; -         _4 = Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}>::new_unchecked(move _5) -> [return: bb2, unwind: bb5]; -     } - -     bb2: { +         _4 = Pin::<&mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}> { __pointer: _5 }; StorageDead(_5); StorageLive(_6); StorageLive(_7); StorageLive(_8); _8 = move _4; StorageLive(_9); _10 = deref_copy (_1.1: &mut std::task::Context<'_>); _9 = &mut (*_10); -         _7 = <{async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6} as Future>::poll(move _8, move _9) -> [return: bb3, unwind: bb5]; +         StorageLive(_11); +         StorageLive(_15); +         StorageLive(_16); +         StorageLive(_25); +         StorageLive(_27); +         StorageLive(_30); +         StorageLive(_31); +         StorageLive(_32); +         StorageLive(_33); +         StorageLive(_34); +         StorageLive(_35); +         StorageLive(_36); +         StorageLive(_37); +         StorageLive(_38); +         StorageLive(_39); +         StorageLive(_40); +         StorageLive(_41); +         StorageLive(_42); +         _33 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         _32 = discriminant((*_33)); +         switchInt(move _32) -> [0: bb5, 1: bb22, 2: bb21, 3: bb20, otherwise: bb10]; } -     bb3: { +     bb1: { +         StorageDead(_2); +         return; +     } + +     bb2 (cleanup): { +         drop(_2) -> [return: bb3, unwind terminate(cleanup)]; +     } + +     bb3 (cleanup): { +         resume; +     } + +     bb4: { +         StorageDead(_42); +         StorageDead(_41); +         StorageDead(_40); +         StorageDead(_39); +         StorageDead(_38); +         StorageDead(_37); +         StorageDead(_36); +         StorageDead(_35); +         StorageDead(_34); +         StorageDead(_33); +         StorageDead(_32); +         StorageDead(_31); +         StorageDead(_30); +         StorageDead(_27); +         StorageDead(_25); +         StorageDead(_16); +         StorageDead(_15); +         StorageDead(_11); StorageDead(_9); StorageDead(_8); StorageDead(_7); _6 = const (); StorageDead(_6); _0 = const (); StorageDead(_4); -         drop(_2) -> [return: bb4, unwind: bb6]; +         drop(_2) -> [return: bb1, unwind: bb3]; } -     bb4: { -         StorageDead(_2); -         return; +     bb5: { +         _31 = move _9; +         _34 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         _35 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         (((*_34) as variant#3).0: ActionPermit<'_, T>) = move ((*_35).0: ActionPermit<'_, T>); +         StorageLive(_12); +         StorageLive(_13); +         StorageLive(_14); +         _14 = (); +         StorageLive(_43); +         _43 = Option::<()>::Some(_14); +         _13 = std::future::Ready::<()>(move _43); +         StorageDead(_43); +         StorageDead(_14); +         _12 = <std::future::Ready<()> as IntoFuture>::into_future(move _13) -> [return: bb6, unwind: bb17]; } -     bb5 (cleanup): { -         drop(_2) -> [return: bb6, unwind terminate(cleanup)]; +     bb6: { +         StorageDead(_13); +         _36 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         (((*_36) as variant#3).1: std::future::Ready<()>) = move _12; +         goto -> bb7; } -     bb6 (cleanup): { -         resume; +     bb7: { +         StorageLive(_17); +         StorageLive(_18); +         StorageLive(_19); +         StorageLive(_20); +         StorageLive(_21); +         _37 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         _21 = &mut (((*_37) as variant#3).1: std::future::Ready<()>); +         _20 = &mut (*_21); +         _19 = Pin::<&mut std::future::Ready<()>>::new_unchecked(move _20) -> [return: bb8, unwind: bb15]; +     } + +     bb8: { +         StorageDead(_20); +         StorageLive(_22); +         StorageLive(_23); +         StorageLive(_24); +         _24 = _31; +         _23 = move _24; +         _22 = &mut (*_23); +         StorageDead(_24); +         _18 = <std::future::Ready<()> as Future>::poll(move _19, move _22) -> [return: bb9, unwind: bb14]; +     } + +     bb9: { +         StorageDead(_22); +         StorageDead(_19); +         _25 = discriminant(_18); +         switchInt(move _25) -> [0: bb12, 1: bb11, otherwise: bb10]; +     } + +     bb10: { +         unreachable; +     } + +     bb11: { +         _17 = const (); +         StorageDead(_23); +         StorageDead(_21); +         StorageDead(_18); +         StorageDead(_17); +         StorageLive(_28); +         StorageLive(_29); +         _29 = (); +         _7 = Poll::<()>::Pending; +         StorageDead(_12); +         StorageDead(_28); +         StorageDead(_29); +         _38 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         discriminant((*_38)) = 3; +         goto -> bb4; +     } + +     bb12: { +         StorageLive(_26); +         _26 = ((_18 as Ready).0: ()); +         _30 = _26; +         StorageDead(_26); +         StorageDead(_23); +         StorageDead(_21); +         StorageDead(_18); +         StorageDead(_17); +         StorageDead(_12); +         _39 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         drop((((*_39) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb13, unwind: bb19]; +     } + +     bb13: { +         _7 = Poll::<()>::Ready(move _30); +         _40 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         discriminant((*_40)) = 1; +         goto -> bb4; +     } + +     bb14 (cleanup): { +         StorageDead(_22); +         StorageDead(_19); +         StorageDead(_23); +         goto -> bb16; +     } + +     bb15 (cleanup): { +         StorageDead(_20); +         StorageDead(_19); +         goto -> bb16; +     } + +     bb16 (cleanup): { +         StorageDead(_21); +         StorageDead(_18); +         StorageDead(_17); +         goto -> bb18; +     } + +     bb17 (cleanup): { +         StorageDead(_13); +         goto -> bb18; +     } + +     bb18 (cleanup): { +         StorageDead(_12); +         _41 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         drop((((*_41) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb19, unwind terminate(cleanup)]; +     } + +     bb19 (cleanup): { +         _42 = deref_copy (_8.0: &mut {async fn body@$DIR/inline_coroutine_body.rs:25:28: 27:6}); +         discriminant((*_42)) = 2; +         goto -> bb2; +     } + +     bb20: { +         StorageLive(_12); +         StorageLive(_28); +         StorageLive(_29); +         _28 = move _9; +         StorageDead(_29); +         _31 = move _28; +         StorageDead(_28); +         _16 = const (); +         goto -> bb7; +     } + +     bb21: { +         assert(const false, "`async fn` resumed after panicking") -> [success: bb21, unwind: bb2]; +     } + +     bb22: { +         assert(const false, "`async fn` resumed after completion") -> [success: bb22, unwind: bb2]; } } </ins>

Discussion:
on commit If you don't set a you will OOM while optimizing syn with these very silly flags. I also have another example of this that produces a "but found ConstICE. They look similar, I'll post the other one later if someone wants.
I've been able to minimize to this:
Here is a further minimized -only repro: The came out of the innards of . The use of is not critical, but the use of a type with both a lifetime and a type generic is; for example, will do too. Tested with the above RUSTFLAGS, under . T/ <details<summaryBacktrace</summary</details