Change:
<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read "Rust Bug Minimization Patterns" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: The error does not happen with any of the 3 changes bellow Remove the async keyword Remove the parameter from the trait function Add the type constraint to struct
label +A-llvm +A-debuginfo +F-asyncfnin_trait Requires and to reproduce As far as I can tell this has caused an ICE since it was introduced in With debug assertions, this fails a bit earlier:
This should be fixed by , if that ever lands.

Discussion:
// to make sure we don't forget to fold the substs regardless. match kind { <del> // This is really important. While we *can* handle this, this has // severe performance implications for large opaque types with // late-bound regions. See `issue-88862` benchmark. ty::Opaque if !data.substs.has_escaping_bound_vars() => { </del> <ins> ty::Opaque => { </ins> // Only normalize `impl Trait` outside of type inference, usually in codegen. match self.param_env.reveal() { Reveal::UserFacing => ty.super_fold_with(self),

} } } <del> ty::Opaque => ty.super_fold_with(self), </del> ty::Projection if !data.has_escaping_bound_vars() => { // This branch is *mostly* just an optimization: when we don't

// Wrap this in a closure so we don't accidentally return from the outer function let res = match kind { <del> // This is really important. While we *can* handle this, this has // severe performance implications for large opaque types with // late-bound regions. See `issue-88862` benchmark. ty::Opaque if !data.substs.has_escaping_bound_vars() => { </del> <ins> ty::Opaque => { </ins> // Only normalize `impl Trait` outside of type inference, usually in codegen. match self.param_env.reveal() { Reveal::UserFacing => ty.try_super_fold_with(self)?,

} } <del> ty::Opaque => ty.try_super_fold_with(self)?, </del> ty::Projection | ty::Inherent | ty::Weak => { // See note in `rustc_trait_selection::traits::project`

use rustc_infer::infer::TyCtxtInferExt; use rustc_infer::traits::{FulfillmentErrorCode, TraitEngineExt as _}; <del> use rustc_middle::traits::{CodegenObligationError, DefiningAnchor}; </del> <ins> use rustc_middle::traits::CodegenObligationError; </ins> use rustc_middle::ty::{self, TyCtxt}; use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt; use rustc_trait_selection::traits::{

// Do the initial selection for the obligation. This yields the // shallow result we are looking for -- that is, what specific impl. <del> let infcx = tcx .infer_ctxt() .ignoring_regions() .with_opaque_type_inference(DefiningAnchor::Bubble) .build(); //~^ HACK `Bubble` is required for // this test to pass: type-alias-impl-trait/assoc-projection-ice.rs </del> <ins> let infcx = tcx.infer_ctxt().ignoring_regions().build(); </ins> let mut selcx = SelectionContext::new(&infcx); let obligation_cause = ObligationCause::dummy();

let impl_source = infcx.resolve_vars_if_possible(impl_source); let impl_source = infcx.tcx.erase_regions(impl_source); <del> // Opaque types may have gotten their hidden types constrained, but we can ignore them safely // as they will get constrained elsewhere, too. // (ouz-a) This is required for `type-alias-impl-trait/assoc-projection-ice.rs` to pass let _ = infcx.take_opaque_types(); </del> Ok(&*tcx.arena.alloc(impl_source)) }

<ins> // build-pass // edition:2021 // compile-flags: -Cdebuginfo=2 // We were not normalizing opaques with escaping bound vars during codegen, // leading to later errors during debuginfo computation. #![feature(async_fn_in_trait)] #[derive(Clone, Copy)] pub struct SharedState {} pub trait State { async fn execute(self, shared_state: &SharedState); } pub trait StateComposer { fn and_then<T, F>(self, map_fn: F) -> AndThen<Self, F> where Self: State + Sized, T: State, F: FnOnce() -> T, { AndThen { previous: self, map_fn } } } impl<T> StateComposer for T where T: State {} pub struct AndThen<T, F> { previous: T, map_fn: F, } impl<T, U, F> State for AndThen<T, F> where T: State, U: State, F: FnOnce() -> U, { async fn execute(self, shared_state: &SharedState) where Self: Sized, { self.previous.execute(shared_state).await; (self.map_fn)().execute(shared_state).await } } pub struct SomeState {} impl State for SomeState { async fn execute(self, shared_state: &SharedState) {} } pub fn main() { let shared_state = SharedState {}; async { SomeState {} .and_then(|| SomeState {}) .and_then(|| SomeState {}) .execute(&shared_state) .await; }; } </ins>

<ins> // build-pass // edition:2021 // compile-flags: -Cdebuginfo=2 // We were not normalizing opaques with escaping bound vars during codegen, // leading to later linker errors because of differences in mangled symbol name. fn func<T>() -> impl Sized {} trait Trait<'a> { type Assoc; fn call() { let _ = async { let _value = func::<Self::Assoc>(); std::future::ready(()).await }; } } impl Trait<'static> for () { type Assoc = (); } fn main() { <()>::call(); } </ins>