Higher-order bound on associated type does not support type inference

[danielhenrymantilla]

I tried this code:

trait SomeBound {} // e.g., `Sized`, `Copy`, `Debug`, or w/e

trait Trait<'__> {
    // Notice that in the general case we don't know
    // if `Assoc : SomeBound` holds.
    type Assoc : ?Sized;
}

impl Trait<'_> for () {
    type Assoc = u8;
}
impl SomeBound for u8 {}

fn check<T>(_: T)
where
    for<'any>
        T : Trait<'any>
    ,
    for<'any>
        <T as Trait<'any>>::Assoc : SomeBound
    ,
{}

fn main() {
    check::<()>(()); // OK
    check::<_> (()); // Errors
    check      (()); // Errors
}

I expected to see this happen: Code compiles fine, whether T is inferred to be () or explicitly turbofished

Instead, this happened: when T is inferred (explicitly or implicitly), an error about the trait for<'any> Bound not being satisfied for <_ as Trait<'any>>::Assoc:

error[[E0277]](https://doc.rust-lang.org/stable/error-index.html#E0277): the trait bound `for<'any> <_ as Trait<'any>>::Assoc: SomeBound` is not satisfied
  --> src/main.rs:26:5
   |
26 |     check::<_>(()); // Errors
   |     ^^^^^^^^^^ the trait `for<'any> SomeBound` is not implemented for `<_ as Trait<'any>>::Assoc`
   |
note: required by a bound in `check`
  --> src/main.rs:20:37
   |
14 | fn check<T>(_: T)
   |    ----- required by a bound in this
...
20 |         <T as Trait<'any>>::Assoc : SomeBound
   |                                     ^^^^^^^^^ required by this bound in `check`

• Demo

This happens on all versions of Rust (up to 1.0.0!)

@rustbot modify labels: A-traits

[danielhenrymantilla]

FWIW, here is the current way to work around this:

1. Define a helper trait with a bound on the associated type:

   trait TraitWithBoundOnAssoc<'lt> {
       type Assoc : ?Sized + SomeBound;
   }

2. Have a blanket impl to forward the original implementations that meet the bound to this new trait (this impl is not higher-order, thereby dodging the issue):

   impl<'lt, T : ?Sized> TraitWithBoundOnAssoc<'lt> for T
   where
       T : Trait<'lt>,
       <T as Trait<'lt>>::Assoc : SomeBound,
   {
       type Assoc = <T as Trait<'lt>>::Assoc;
   }

3. Wrap the original function within one which uses this "assoc-type-bounded trait alias" instead, while also adding an equality close in between the two associated types:

   // wrapping function
   fn check<T>(it: T)
   where
       T : for<'any> Trait<'any,
   +       Assoc = <T as TraitWithBoundOnAssoc<'any>>::Assoc,
       >,
       for<'any>
   -      <T as Trait<'any>>::Assoc : SomeBound
   +       T : TraitWithBoundOnAssoc<'any>
       ,
   {
       // original function which can be left untouched:
       fn check<T> …
   
       check::<T>(it) // <- turbofish to avoid the issue mentioned in this very issue!
   }

• Demo

[compiler-errors]

I think this is #88460

[jackh726]

This is #89196. Closing as duplicate.