Trait impl from where clause (ParamEnv) takes precedence over freestanding trait impl

[krtab]

Hi!

Sorry for the poor title, I have no better idea. Feel free to change it to something more appropriate.

I tried this code:

pub fn take_n_bits<S, L>(x: u64, start_from_right: S, length: L) -> u64
where
    u64: std::ops::Shr<S, Output = u64>,
    L: Into<usize>
{
    let shifted : u64 = x >> start_from_right;
    let mask : u64 = !0 >> (std::mem::size_of::<u64>() * 8 - length.into());
    shifted & mask
}

which I expect to compile fine. But instead, I get the typing error:

error[E0308]: mismatched types
 --> src/lib.rs:7:28
  |
1 | pub fn take_n_bits<S, L>(x: u64, start_from_right: S, length: L) -> u64
  |                    - this type parameter
...
7 |     let mask : u64 = !0 >> (std::mem::size_of::<u64>() * 8 - length.into());
  |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected type parameter `S`, found `usize`
  |
  = note: expected type parameter `S`
                       found type `usize`

error: aborting due to previous error

(playground link)

Meta

(afaict this is present in stable, beta and nightly)

rustc --version --verbose:

rustc 1.53.0-nightly (d0695c908 2021-04-12)
binary: rustc
commit-hash: d0695c9081b16077d0aed368bccaf437d77ff497
commit-date: 2021-04-12
host: x86_64-unknown-linux-gnu
release: 1.53.0-nightly
LLVM version: 12.0.0

[Globidev]

here is a minimal reproduction of the issue

use std::ops::Shr;

fn works() { 1_u64 >> 2_u32; }

fn breaks<T>()
where 
    u64: Shr<T>
{ 
    1_u64 >> 2_u32; 
}

It looks like the compiler unnecessarily restricts to the Shr<T> impl instead of inferring the type parameter of Shr from the rhs and picking Shr<u32> in that case

More strange scenarios (as of Nightly version: 1.53.0-nightly (2021-04-14 16bf626a31cb5b121d0b)):

use std::ops::Shr;

fn works() { 1_u64 >> 2_u32; }

fn breaks<T>()          where u64: Shr<T>              { 1_u64 >> 2_u32; }
fn breaks_too<T>()      where u64: Shr<u32> + Shr<T>   { 1_u64 >> 2_u32; }
fn breaks_as_well<T>()  where u64: Shr<u32> + Shr<T>   { Shr::<_>::shr(1_u64, 2_u32); } // Should be infered to `Shr::<u32>` from my understanding, but doesn't seem to be the case
fn works_though<T>()    where u64: Shr<T>              { Shr::<u32>::shr(1_u64, 2_u32); }
fn works_too<T>()       where u64: Shr<u32> + Shr<T>   { Shr::<u32>::shr(1_u64, 2_u32); }

fn works_more_surprisingly<T, U>()
where 
    u64: Shr<T> + Shr<U> // An additional bound on another generic parameter seems to fix the resolution ??
{ 
    1_u64 >> 2_u32; 
}

fn works_more_surprisingly_in_full_form_too<T, U>()
where 
    u64: Shr<T> + Shr<U>
{ 
    Shr::<_>::shr(1_u64, 2_u32);
}

playground link for those

[jonas-schievink]

I think this is currently working as expected, since trait bounds on where clauses have precedence over freestanding trait implementations

[Globidev]

I feel like that does not explain the last two cases of the last snippet above though, where having two trait bounds instead of one suddenly "re-enables" the freestanding trait implementation

[Cerber-Ursi]

Probably duplicate of #24066.

[fmease]

Closing as duplicate of #24066.