Enable deducing future output for impl trait in trait

compiler/rustc_hir_typeck/src/closure.rs

@@ -760,16 +760,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     get_future_output(obligation.predicate, obligation.cause.span)
                 })?
             }
-            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::Alias(kind, ty::AliasTy { def_id, args, .. }) => {
+                match kind {
+                    ty::Projection => assert!(self.tcx.is_impl_trait_in_trait(def_id)),
+                    ty::Opaque => {}
+                    ty::Inherent | ty::Weak => span_bug!(
+                        closure_span,
+                        "invalid async fn coroutine return type: {ret_ty:?}"
+                    ),
+                }
+                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),
-            _ => span_bug!(
-                closure_span,
-                "async fn coroutine return type not an inference variable: {ret_ty}"
-            ),
+            _ => {
+                span_bug!(closure_span, "invalid async fn coroutine return type: {ret_ty:?}")
+            }
         };
 
         let output_ty = self.normalize(closure_span, output_ty);

tests/ui/async-await/inference_var_self_argument.rs

@@ -0,0 +1,12 @@
+//! 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() {}

tests/ui/async-await/inference_var_self_argument.stderr

@@ -0,0 +1,28 @@
+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`.