erase regions in cause code when giving suggestion

Author: adwinwhite

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -1499,7 +1499,35 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         };
 
         if let ObligationCauseCode::ImplDerived(cause) = &*code {
-            try_borrowing(cause.derived.parent_trait_pred, &[])
+            // Parent trait predicate may contain regions that's already popped since `cause`
+            // in `Obligation` is ignored by folders/visitors.
+            // We can erase them since evaluation later doesn't care about regions anyway.
+            struct PoppedRegionEraser<'a, 'tcx> {
+                infcx: &'a InferCtxt<'tcx>,
+            }
+            impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for PoppedRegionEraser<'a, 'tcx> {
+                fn cx(&self) -> TyCtxt<'tcx> {
+                    self.infcx.tcx
+                }
+
+                fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
+                    if ty.has_infer_regions() { ty.super_fold_with(self) } else { ty }
+                }
+
+                fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
+                    if let ty::ReVar(vid) = r.kind()
+                        && vid.index() >= self.infcx.num_region_vars()
+                    {
+                        self.infcx.tcx.lifetimes.re_erased
+                    } else {
+                        r
+                    }
+                }
+            }
+
+            let parent_trait_pred =
+                cause.derived.parent_trait_pred.fold_with(&mut PoppedRegionEraser { infcx: self });
+            try_borrowing(parent_trait_pred, &[])
         } else if let ObligationCauseCode::WhereClause(..)
         | ObligationCauseCode::WhereClauseInExpr(..) = code
         {

tests/ui/traits/next-solver/normalize/outdated-region-in-cause-code.rs

@@ -0,0 +1,43 @@
+//@ compile-flags: -Znext-solver
+//@ edition: 2024
+//
+// A regression test for the ICE variant in trait-system-refactor-initiative#245.
+// We'll meet regions that're already popped off when using parent predicate in cause code.
+// `cause` in `Obligation` is ignored by folders/visitors.
+// In this case, `fudge_inference_if_ok` doesn't fudge a region var in cause code.
+//
+// The old solver doesn't trigger ICE because regions in the predicate are replaced with
+// placeholders when checking generator witness. Besides, the old solver doesn't eagerly
+// resolves vars before canonicalizing the predicate in `predicate_must_hold_modulo_regions`.
+
+trait AsyncFn: Send + 'static {
+    type Fut: Future<Output = ()> + Send;
+
+    fn call(&self) -> Self::Fut;
+}
+
+async fn wrap_call<P: AsyncFn + ?Sized>(filter: &P) {
+    filter.call().await;
+}
+
+fn get_boxed_fn() -> Box<DynAsyncFnBoxed> {
+    todo!()
+}
+
+async fn cursed_fut() {
+    wrap_call(get_boxed_fn().as_ref()).await;
+}
+
+fn observe_fut_not_send() {
+    assert_send(cursed_fut());
+    //~^ ERROR: `dyn AsyncFn<Fut = Pin<Box<dyn Future<Output = ()> + Send>>>` cannot be shared between threads safely [E0277]
+}
+
+fn assert_send<T: Send>(t: T) -> T {
+    t
+}
+
+pub type BoxFuture<'a, T> = std::pin::Pin<Box<dyn Future<Output = T> + Send + 'a>>;
+type DynAsyncFnBoxed = dyn AsyncFn<Fut = BoxFuture<'static, ()>>;
+
+fn main() {}

tests/ui/traits/next-solver/normalize/outdated-region-in-cause-code.stderr

@@ -0,0 +1,35 @@
+error[E0277]: `dyn AsyncFn<Fut = Pin<Box<dyn Future<Output = ()> + Send>>>` cannot be shared between threads safely
+  --> $DIR/outdated-region-in-cause-code.rs:32:17
+   |
+LL |     assert_send(cursed_fut());
+   |     ----------- ^^^^^^^^^^^^ `dyn AsyncFn<Fut = Pin<Box<dyn Future<Output = ()> + Send>>>` cannot be shared between threads safely
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the trait `Sync` is not implemented for `dyn AsyncFn<Fut = Pin<Box<dyn Future<Output = ()> + Send>>>`
+   = note: required for `&dyn AsyncFn<Fut = Pin<Box<dyn Future<Output = ()> + Send>>>` to implement `Send`
+note: required because it's used within this `async` fn body
+  --> $DIR/outdated-region-in-cause-code.rs:19:53
+   |
+LL |   async fn wrap_call<P: AsyncFn + ?Sized>(filter: &P) {
+   |  _____________________________________________________^
+LL | |     filter.call().await;
+LL | | }
+   | |_^
+note: required because it's used within this `async` fn body
+  --> $DIR/outdated-region-in-cause-code.rs:27:23
+   |
+LL |   async fn cursed_fut() {
+   |  _______________________^
+LL | |     wrap_call(get_boxed_fn().as_ref()).await;
+LL | | }
+   | |_^
+note: required by a bound in `assert_send`
+  --> $DIR/outdated-region-in-cause-code.rs:36:19
+   |
+LL | fn assert_send<T: Send>(t: T) -> T {
+   |                   ^^^^ required by this bound in `assert_send`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.