Revert to inference variable based hidden type computation for RPIT

Author: oli-obk

compiler/rustc_infer/src/infer/opaque_types.rs

@@ -510,7 +510,7 @@ impl UseKind {
 
 impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     #[instrument(skip(self), level = "debug")]
-    fn register_hidden_type(
+    pub fn register_hidden_type(
         &self,
         opaque_type_key: OpaqueTypeKey<'tcx>,
         cause: ObligationCause<'tcx>,

compiler/rustc_typeck/src/check/check.rs

@@ -3,6 +3,7 @@ use super::compare_method::check_type_bounds;
 use super::compare_method::{compare_const_impl, compare_impl_method, compare_ty_impl};
 use super::*;
 
+use hir::OpaqueTyOrigin;
 use rustc_attr as attr;
 use rustc_errors::{Applicability, ErrorGuaranteed};
 use rustc_hir as hir;
@@ -12,8 +13,9 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::{def::Res, ItemKind, Node, PathSegment};
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
+use rustc_infer::traits::ObligationCause;
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::fold::TypeFoldable;
+use rustc_middle::ty::fold::{BottomUpFolder, TypeFoldable};
 use rustc_middle::ty::layout::{LayoutError, MAX_SIMD_LANES};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::util::{Discr, IntTypeExt};
@@ -95,7 +97,46 @@ pub(super) fn check_fn<'a, 'tcx>(
 
     let declared_ret_ty = fn_sig.output();
 
-    fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(declared_ret_ty)));
+    let ret_ty = declared_ret_ty.fold_with(&mut BottomUpFolder {
+        tcx: fcx.tcx,
+        ty_op: |ty| match *ty.kind() {
+            ty::Opaque(def_id, substs) => {
+                let span = tcx.def_span(def_id);
+                if let Some(origin @ OpaqueTyOrigin::FnReturn(_)) =
+                    fcx.infcx.opaque_type_origin(def_id, span)
+                {
+                    let hidden_ty = fcx.infcx.next_ty_var(TypeVariableOrigin {
+                        kind: TypeVariableOriginKind::MiscVariable,
+                        span: span,
+                    });
+
+                    let cause = ObligationCause::misc(span, body.value.hir_id);
+                    match fcx.infcx.register_hidden_type(
+                        ty::OpaqueTypeKey { def_id, substs },
+                        cause.clone(),
+                        param_env,
+                        hidden_ty,
+                        origin,
+                    ) {
+                        Ok(infer_ok) => {
+                            fcx.register_infer_ok_obligations(infer_ok);
+                            hidden_ty
+                        }
+                        Err(err) => {
+                            fcx.report_mismatched_types(&cause, ty, hidden_ty, err).emit();
+                            tcx.ty_error()
+                        }
+                    }
+                } else {
+                    ty
+                }
+            }
+            _ => ty,
+        },
+        lt_op: |lt| lt,
+        ct_op: |ct| ct,
+    });
+    fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
     fcx.ret_type_span = Some(decl.output.span());
 
     let span = body.value.span;

compiler/rustc_typeck/src/check/writeback.rs

@@ -20,6 +20,7 @@ use rustc_span::symbol::sym;
 use rustc_span::Span;
 
 use std::mem;
+use std::ops::ControlFlow;
 
 ///////////////////////////////////////////////////////////////////////////
 // Entry point
@@ -503,7 +504,28 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
         for (opaque_type_key, decl) in opaque_types {
             let hidden_type = match decl.origin {
                 hir::OpaqueTyOrigin::FnReturn(_) | hir::OpaqueTyOrigin::AsyncFn(_) => {
-                    Some(self.resolve(decl.hidden_type.ty, &decl.hidden_type.span))
+                    let ty = self.resolve(decl.hidden_type.ty, &decl.hidden_type.span);
+                    struct RecursionChecker {
+                        def_id: DefId,
+                    }
+                    impl<'tcx> ty::TypeVisitor<'tcx> for RecursionChecker {
+                        type BreakTy = ();
+                        fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
+                            if let ty::Opaque(def_id, _) = *t.kind() {
+                                if def_id == self.def_id {
+                                    return ControlFlow::Break(());
+                                }
+                            }
+                            t.super_visit_with(self)
+                        }
+                    }
+                    if ty
+                        .visit_with(&mut RecursionChecker { def_id: opaque_type_key.def_id })
+                        .is_break()
+                    {
+                        return;
+                    }
+                    Some(ty)
                 }
                 hir::OpaqueTyOrigin::TyAlias => None,
             };

src/test/ui/associated-types/impl-trait-return-missing-constraint.rs

@@ -23,8 +23,9 @@ fn bar() -> impl Bar {
 }
 
 fn baz() -> impl Bar<Item = i32> {
-    bar()
     //~^ ERROR type mismatch resolving `<impl Bar as Foo>::Item == i32`
+    //~| ERROR type mismatch resolving `<impl Bar as Foo>::Item == i32`
+    bar()
 }
 
 fn main() {

src/test/ui/associated-types/impl-trait-return-missing-constraint.stderr

@@ -1,11 +1,11 @@
 error[E0271]: type mismatch resolving `<impl Bar as Foo>::Item == i32`
-  --> $DIR/impl-trait-return-missing-constraint.rs:26:5
+  --> $DIR/impl-trait-return-missing-constraint.rs:25:13
    |
 LL | fn bar() -> impl Bar {
    |             -------- the expected opaque type
 ...
-LL |     bar()
-   |     ^^^^^ expected associated type, found `i32`
+LL | fn baz() -> impl Bar<Item = i32> {
+   |             ^^^^^^^^^^^^^^^^^^^^ expected associated type, found `i32`
    |
    = note: expected associated type `<impl Bar as Foo>::Item`
                          found type `i32`
@@ -16,6 +16,29 @@ help: consider constraining the associated type `<impl Bar as Foo>::Item` to `i3
 LL | fn bar() -> impl Bar<Item = i32> {
    |                     ++++++++++++
 
-error: aborting due to previous error
+error[E0271]: type mismatch resolving `<impl Bar as Foo>::Item == i32`
+  --> $DIR/impl-trait-return-missing-constraint.rs:25:34
+   |
+LL |   fn bar() -> impl Bar {
+   |               -------- the expected opaque type
+...
+LL |   fn baz() -> impl Bar<Item = i32> {
+   |  __________________________________^
+LL | |
+LL | |
+LL | |     bar()
+LL | | }
+   | |_^ expected associated type, found `i32`
+   |
+   = note: expected associated type `<impl Bar as Foo>::Item`
+                         found type `i32`
+   = help: consider constraining the associated type `<impl Bar as Foo>::Item` to `i32` or calling a method that returns `<impl Bar as Foo>::Item`
+   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
+help: consider constraining the associated type `<impl Bar as Foo>::Item` to `i32`
+   |
+LL | fn bar() -> impl Bar<Item = i32> {
+   |                     ++++++++++++
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0271`.

src/test/ui/async-await/issue-64130-4-async-move.rs

@@ -13,9 +13,9 @@ impl Client {
 async fn get() { }
 
 pub fn foo() -> impl Future + Send {
+    //~^ ERROR future cannot be sent between threads safely
     let client = Client(Box::new(true));
     async move {
-        //~^ ERROR future cannot be sent between threads safely
         match client.status() {
             200 => {
                 let _x = get().await;

src/test/ui/async-await/issue-64130-4-async-move.stderr

@@ -1,8 +1,8 @@
 error: future cannot be sent between threads safely
-  --> $DIR/issue-64130-4-async-move.rs:17:5
+  --> $DIR/issue-64130-4-async-move.rs:15:17
    |
-LL |     async move {
-   |     ^^^^^^^^^^ future created by async block is not `Send`
+LL | pub fn foo() -> impl Future + Send {
+   |                 ^^^^^^^^^^^^^^^^^^ future created by async block is not `Send`
    |
    = help: the trait `Sync` is not implemented for `(dyn Any + Send + 'static)`
 note: future is not `Send` as this value is used across an await

src/test/ui/async-await/issue-70818.rs

@@ -2,8 +2,8 @@
 
 use std::future::Future;
 fn foo<T: Send, U>(ty: T, ty1: U) -> impl Future<Output = (T, U)> + Send {
-    async { (ty, ty1) }
     //~^ Error future cannot be sent between threads safely
+    async { (ty, ty1) }
 }
 
 fn main() {}

src/test/ui/async-await/issue-70818.stderr

@@ -1,11 +1,11 @@
 error: future cannot be sent between threads safely
-  --> $DIR/issue-70818.rs:5:5
+  --> $DIR/issue-70818.rs:4:38
    |
-LL |     async { (ty, ty1) }
-   |     ^^^^^ future created by async block is not `Send`
+LL | fn foo<T: Send, U>(ty: T, ty1: U) -> impl Future<Output = (T, U)> + Send {
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future created by async block is not `Send`
    |
 note: captured value is not `Send`
-  --> $DIR/issue-70818.rs:5:18
+  --> $DIR/issue-70818.rs:6:18
    |
 LL |     async { (ty, ty1) }
    |                  ^^^ has type `U` which is not `Send`

src/test/ui/async-await/issue-70935-complex-spans.rs

@@ -8,8 +8,8 @@ async fn baz<T>(_c: impl FnMut() -> T) where T: Future<Output=()> {
 }
 
 fn foo(tx: std::sync::mpsc::Sender<i32>) -> impl Future + Send {
+    //~^ ERROR: future cannot be sent between threads safely
     async move {
-        //~^ ERROR: future cannot be sent between threads safely
         baz(|| async{
             foo(tx.clone());
         }).await;