1 files changed, 37 insertions, 2 deletions

diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 1e748476a..4a7d3a0d9 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -33,6 +33,7 @@ use hir_def::{
     AdtId, AssocContainerId, DefWithBodyId, GenericDefId, HasModule, Lookup, TraitId, TypeAliasId,
     TypeParamId,
 };
+use hir_expand::name::name;
 use itertools::Itertools;
 
 use crate::{
@@ -129,8 +130,9 @@ pub enum TypeCtor {
 
     /// This represents a placeholder for an opaque type in situations where we
     /// don't know the hidden type (i.e. currently almost always). This is
-    /// analogous to the `AssociatedType` type constructor. As with that one,
-    /// these are only produced by Chalk.
+    /// analogous to the `AssociatedType` type constructor.
+    /// It is also used as the type of async block, with one type parameter
+    /// representing the Future::Output type.
     OpaqueType(OpaqueTyId),
 
     /// The type of a specific closure.
@@ -173,6 +175,8 @@ impl TypeCtor {
                         let generic_params = generics(db.upcast(), func.into());
                         generic_params.len()
                     }
+                    // 1 param representing Future::Output type.
+                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => 1,
                 }
             }
             TypeCtor::FnPtr { num_args, is_varargs: _ } => num_args as usize + 1,
@@ -205,6 +209,7 @@ impl TypeCtor {
                 OpaqueTyId::ReturnTypeImplTrait(func, _) => {
                     Some(func.lookup(db.upcast()).module(db.upcast()).krate)
                 }
+                OpaqueTyId::AsyncBlockTypeImplTrait(def, _) => Some(def.module(db.upcast()).krate),
             },
         }
     }
@@ -843,6 +848,33 @@ impl Ty {
 
     pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
         match self {
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::OpaqueType(opaque_ty_id), parameters }) => {
+                match opaque_ty_id {
+                    OpaqueTyId::AsyncBlockTypeImplTrait(def, _expr) => {
+                        let krate = def.module(db.upcast()).krate;
+                        if let Some(future_output) = db
+                            .lang_item(krate, "future_trait".into())
+                            .and_then(|item| item.as_trait())
+                            .and_then(|trait_| {
+                                db.trait_data(trait_).associated_type_by_name(&name![Output])
+                            })
+                        {
+                            let proj = GenericPredicate::Projection(ProjectionPredicate {
+                                projection_ty: ProjectionTy {
+                                    associated_ty: future_output,
+                                    // Self type.
+                                    parameters: Substs::single(self.clone()),
+                                },
+                                ty: parameters[0].clone(),
+                            });
+                            Some(vec![proj])
+                        } else {
+                            None
+                        }
+                    }
+                    OpaqueTyId::ReturnTypeImplTrait(..) => None,
+                }
+            }
             Ty::Opaque(opaque_ty) => {
                 let predicates = match opaque_ty.opaque_ty_id {
                     OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
@@ -853,6 +885,8 @@ impl Ty {
                             data.subst(&opaque_ty.parameters)
                         })
                     }
+                    // It always has an parameter for Future::Output type.
+                    OpaqueTyId::AsyncBlockTypeImplTrait(..) => unreachable!(),
                 };
 
                 predicates.map(|it| it.value)
@@ -1065,6 +1099,7 @@ impl<T: TypeWalk> TypeWalk for Vec<T> {
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum OpaqueTyId {
     ReturnTypeImplTrait(hir_def::FunctionId, u16),
+    AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId),
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]