Normalize return type of deduce_future_output_from_obligations

compiler/rustc_hir_typeck/src/closure.rs

@@ -711,6 +711,8 @@ fn deduce_future_output_from_obligations(
             }
         };
 
+        let span = self.tcx.def_span(expr_def_id);
+
         let output_ty = match *ret_ty.kind() {
             ty::Infer(ty::TyVar(ret_vid)) => {
                 self.obligations_for_self_ty(ret_vid).find_map(|obligation| {
@@ -724,20 +726,17 @@ fn deduce_future_output_from_obligations(
                 .find_map(|(p, s)| get_future_output(p.as_predicate(), s))?,
             ty::Error(_) => return None,
             _ => span_bug!(
-                self.tcx.def_span(expr_def_id),
+                span,
                 "async fn generator return type not an inference variable: {ret_ty}"
             ),
         };
 
+        let output_ty = self.normalize(span, output_ty);
+
         // async fn that have opaque types in their return type need to redo the conversion to inference variables
         // as they fetch the still opaque version from the signature.
         let InferOk { value: output_ty, obligations } = self
-            .replace_opaque_types_with_inference_vars(
-                output_ty,
-                body_def_id,
-                self.tcx.def_span(expr_def_id),
-                self.param_env,
-            );
+            .replace_opaque_types_with_inference_vars(output_ty, body_def_id, span, self.param_env);
         self.register_predicates(obligations);
 
         Some(output_ty)

tests/ui/async-await/normalize-output-in-signature-deduction.rs

@@ -0,0 +1,19 @@
+// edition:2021
+// revisions: current next
+//[next] compile-flags: -Ztrait-solver=next
+// check-pass
+
+#![feature(type_alias_impl_trait)]
+
+struct Foo;
+
+impl Trait for Foo {}
+pub trait Trait {}
+
+pub type TAIT<T> = impl Trait;
+
+async fn foo<T>() -> TAIT<T> {
+    Foo
+}
+
+fn main() {}