hopefully irrelevant candidate behavior difference of Sized/trivial builtin impls

[lcnr]

struct MaybeSized<T: ?Sized>(T);

fn is_sized<T: Sized>() -> Box<T> { todo!() }

fn foo<T: ?Sized>()
where
    MaybeSized<T>: Sized,
{
    is_sized::<MaybeSized<_>>();
}

this compiles with the old solver, inferring the _ to T. It has a ParamEnv and a BuiltinCandidate { has_nested: true } candidate and prefers the ParamEnv candidate here.

The new solver encounters a trivial impl candidate and a ParamEnv one, preferring the trivial builtin.

[lcnr]

The old solver only considers Sized impls to be trivial if the sized_conditions are empty. This means that even with a trivially true condition we prefer where-bounds. This results in the following inconsistent behavior:

trait Trait<T>: Sized {}
impl<T> Trait<T> for T {}

fn is_sized<T: Sized>() {}

fn normal_ref<'a, 'b, T>()
where
    &'a u32: Trait<T>,
{
    // Uses builtin impl, OK
    is_sized::<&'b u32>();
}

struct MyRef<'a, U: ?Sized = ()>(&'a u32, U);
fn my_ref<'a, 'b, T>()
where
    MyRef<'a>: Trait<T>,
{
    // Uses where-bound, lifetime error
    is_sized::<MyRef<'b>>();
}