Change:
<!-- [31mICE[0m: Rustc '' 'error: internal compiler error: async fn coroutine return type not an inference variable: impl Future<Output = &'b ()', 'error: internal compiler error: async fn coroutine return type not an inference variable: impl Future<Output = &'b ()' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [typeofopaque] computing type of opaque [typeof] computing type of [checkwellformed] checking that is well-formed [checkmodtypewf] checking that types are well-formed in module [analysis] running analysis passes on this crate --
Also ices in Rust 2021 in case anybody was wondering. Further reduced:
(see below)
It's of course :upsidedownface:
fyi

Discussion:
get_future_output(obligation.predicate, obligation.cause.span) })? } <ins> ty::Alias(ty::Projection, _) => { return Some(Ty::new_error_with_message( self.tcx, closure_span, "this projection should have been projected to an opaque type", )); } </ins> ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => self .tcx .explicit_item_bounds(def_id) .iter_instantiated_copied(self.tcx, args) .find_map(|(p, s)| get_future_output(p.as_predicate(), s))?, ty::Error(_) => return Some(ret_ty), <del> _ => span_bug!( closure_span, "async fn coroutine return type not an inference variable: {ret_ty}" ), </del> <ins> _ => { span_bug!(closure_span, "invalid async fn coroutine return type: {ret_ty:?}") } </ins> }; let output_ty = self.normalize(closure_span, output_ty);

<ins> //! This is a regression test for an ICE. // edition: 2021 trait Foo { async fn foo(self: &dyn Foo) { //~^ ERROR: `Foo` cannot be made into an object //~| ERROR invalid `self` parameter type: &dyn Foo todo!() } } fn main() {} </ins>

<ins> error[E0038]: the trait `Foo` cannot be made into an object --> $DIR/inference_var_self_argument.rs:5:5 | LL |     async fn foo(self: &dyn Foo) { |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Foo` cannot be made into an object | note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> --> $DIR/inference_var_self_argument.rs:5:14 | LL | trait Foo { |       --- this trait cannot be made into an object... LL |     async fn foo(self: &dyn Foo) { |              ^^^ ...because method `foo` is `async` = help: consider moving `foo` to another trait error[E0307]: invalid `self` parameter type: &dyn Foo --> $DIR/inference_var_self_argument.rs:5:24 | LL |     async fn foo(self: &dyn Foo) { |                        ^^^^^^^^ | = note: type of `self` must be `Self` or a type that dereferences to it = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`) error: aborting due to 2 previous errors Some errors have detailed explanations: E0038, E0307. For more information about an error, try `rustc --explain E0038`. </ins>

<ins> trait Foo { fn err(&self) -> MissingType; //~^ ERROR cannot find type `MissingType` in this scope } impl Foo for i32 { fn err(&self) -> MissingType { //~^ ERROR cannot find type `MissingType` in this scope 0 } } fn coerce(x: &i32) -> &dyn Foo { x } fn main() {} </ins>

<ins> error[E0412]: cannot find type `MissingType` in this scope --> $DIR/erroneous_signature.rs:2:22 | LL |     fn err(&self) -> MissingType; |                      ^^^^^^^^^^^ not found in this scope error[E0412]: cannot find type `MissingType` in this scope --> $DIR/erroneous_signature.rs:7:22 | LL |     fn err(&self) -> MissingType { |                      ^^^^^^^^^^^ not found in this scope error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0412`. </ins>