Rollup merge of #157280 - Dnreikronos:existential_trait_ref_escaping_bound_vars_assert, r=lcnr

traits: Allow escaping self types in ExistentialTraitRef::with_self_ty

Fixes #157122

WF-checking recurses through higher-ranked binders without instantiating them, so a `dyn Trait` nested inside a `for<'a>` binder reaches the `ty::Dynamic` arm of `WfPredicates::visit_ty` while still carrying escaping bound vars. Building the principal trait ref there via `ExistentialTraitRef::with_self_ty` hands that escaping self type to a `debug_assert!(!self_ty.has_escaping_bound_vars())`, which ICEs once the assertion is enabled. The assert was accidentally disabled in 2018 refactor #53816, and the `// FIXME(#157122)` left in its place asks whether to remove it or fix the fallout.

An escaping bound var is expected for trait objects, and we already catch trait refs with escaping bound vars at the places that actually use them — so creating one here is fine. Rather than work around the assert in WF, this removes the assert and its stale FIXME from `with_self_ty`.

Two regression tests pin the behavior:
- `wf-dyn-in-hrtb-bound-issue-157122.rs` reproduces the original ICE (`dyn` nested in an HRTB bound).
- `wf-dyn-in-hrtb-bound-const-mismatch.rs` checks that the `ConstArgHasType` obligation this arm reads off still fires, so an ill-typed const argument on such a `dyn` keeps erroring instead of compiling clean.

Author: jhpratt

compiler/rustc_type_ir/src/predicate.rs

@@ -429,13 +429,6 @@ impl<I: Interner> ExistentialTraitRef<I> {
     /// Therefore, you must specify *some* self type to perform the conversion.
     /// A common choice is the trait object type itself or some kind of dummy type.
     pub fn with_self_ty(self, interner: I, self_ty: I::Ty) -> TraitRef<I> {
-        // FIXME(#157122): This assertion was accidentally commented out in refactoring PR #53816
-        //                 back in 2018 but nowadays it can actually trigger. Either remove this
-        //                 comment entirely if the assertion is incorrect or uncomment it and fix
-        //                 the fallout!
-        // otherwise the escaping vars would be captured by the binder
-        //debug_assert!(!self_ty.has_escaping_bound_vars());
-
         TraitRef::new(interner, self.def_id, [self_ty.into()].into_iter().chain(self.args.iter()))
     }
 }

tests/ui/wf/wf-dyn-in-hrtb-bound-const-mismatch.rs

@@ -0,0 +1,19 @@
+// Companion to #157122 / `wf-dyn-in-hrtb-bound-issue-157122.rs`.
+//
+// That test covers an ICE in `WfPredicates::visit_ty` where a `dyn Trait` nested
+// inside a `for<'a>` binder reached `ExistentialTraitRef::with_self_ty` with an
+// escaping self type. The fix removes the offending `debug_assert!` rather than
+// skipping the block. Skipping would have been a silent regression: the block
+// emits the `ConstArgHasType` obligation that type-checks a `dyn`'s const
+// argument, so dropping it makes an ill-typed const argument compile.
+//
+// Here `B` has type `bool` but `HasConst` expects `const N: usize`, and the
+// `dyn HasConst<'a, B>` carries the escaping late-bound `'a`. This must still be
+// rejected, exactly as it is without the surrounding `for<'a>` binder.
+
+trait HasConst<'a, const N: usize> {}
+
+fn nested<const B: bool>(_f: &dyn for<'a> Fn(&'a (), &'a dyn HasConst<'a, B>)) {}
+//~^ ERROR the constant `B` is not of type `usize`
+
+fn main() {}

tests/ui/wf/wf-dyn-in-hrtb-bound-const-mismatch.stderr

@@ -0,0 +1,14 @@
+error: the constant `B` is not of type `usize`
+  --> $DIR/wf-dyn-in-hrtb-bound-const-mismatch.rs:16:30
+   |
+LL | fn nested<const B: bool>(_f: &dyn for<'a> Fn(&'a (), &'a dyn HasConst<'a, B>)) {}
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+   |
+note: required by a const generic parameter in `HasConst`
+  --> $DIR/wf-dyn-in-hrtb-bound-const-mismatch.rs:14:20
+   |
+LL | trait HasConst<'a, const N: usize> {}
+   |                    ^^^^^^^^^^^^^^ required by this const generic parameter in `HasConst`
+
+error: aborting due to 1 previous error
+

tests/ui/wf/wf-dyn-in-hrtb-bound-issue-157122.rs

@@ -0,0 +1,28 @@
+//@ check-pass
+
+// Regression test for #157122.
+//
+// When WF-checking a type, the visitor recurses through higher-ranked binders
+// without instantiating them, so a `dyn Trait` nested inside a `for<'a>` binder
+// reaches the `ty::Dynamic` arm of `WfPredicates::visit_ty` while still carrying
+// escaping bound vars. Building the principal trait ref there via
+// `ExistentialTraitRef::with_self_ty` passed that escaping self type to a
+// `debug_assert!(!self_ty.has_escaping_bound_vars())`, which ICEs once the
+// assertion is enabled. Creating a trait ref with an escaping self type is fine
+// -- escaping bound vars are caught where they are actually used -- so the
+// assertion was removed rather than worked around. The `ConstArgHasType` check
+// this arm reads off still runs; see `wf-dyn-in-hrtb-bound-const-mismatch.rs`.
+// Distilled from `itertools`'s `FormatWith` `Display` impl.
+
+use std::fmt;
+
+fn call<F>(mut f: F)
+where
+    F: FnMut(&mut dyn FnMut(&dyn fmt::Display) -> fmt::Result) -> fmt::Result,
+{
+    let _ = f(&mut |_disp: &dyn fmt::Display| Ok(()));
+}
+
+fn main() {
+    call(|cb| cb(&0i32));
+}