Rust says that a type both implements and doesn't implement a trait.

[theemathas]

Code

struct Dummy;
trait WithLifetime {
    type Output<'a>;
}
impl WithLifetime for Dummy {
    type Output<'a> = &'a ();
}

trait Unimplemented {}

trait Foo {}
impl<T> Foo for T where T: Unimplemented {}
impl<'a> Foo for &'a () where for<'b> Dummy: WithLifetime<Output<'b> = &'a ()> {}

fn what<'a>()
where
    &'a (): Foo,
{
}

fn main() {
    what();
}

Current output

error[E0277]: the trait bound `&(): Foo` is not satisfied
  --> src/main.rs:22:5
   |
22 |     what();
   |     ^^^^^^ the trait `Foo` is not implemented for `&()`
   |
   = help: the trait `Foo` is not implemented for `&()`
           but trait `Foo` is implemented for it
note: required by a bound in `what`
  --> src/main.rs:17:13
   |
15 | fn what<'a>()
   |    ---- required by a bound in this function
16 | where
17 |     &'a (): Foo,
   |             ^^^ required by this bound in `what`

For more information about this error, try `rustc --explain E0277`.

Desired output

Probably don't claim that `&()` both implements and doesn't implement `Foo`

Rationale and extra context

This issue is discovered while minimizing the code from #136666, which ICEs instead.

Other cases

Rust Version

Reproducible on the rust playground with stable rust 1.84.1 and nightly rust `1.86.0-nightly (2025-02-06 942db6782f4a28c55b0b)`

Anything else?

No response

[theemathas]

A variant of what appears to be the same problem:

trait SystemX<R> {}

trait Retriever: 'static {
    type Retriever<'r>;
}
impl Retriever for () {
    type Retriever<'r> = &'r ();
}

impl<R: Retriever> SystemX<R> for for<'a> fn(R::Retriever<'a>) {}

fn main() {
    let func: for<'a> fn(&'a ()) = |_| {};
    let _: Box<dyn SystemX<()>> = Box::new(func);
}

error[E0277]: the trait bound `for<'a> fn(&'a ()): SystemX<()>` is not satisfied
  --> src/main.rs:14:35
   |
14 |     let _: Box<dyn SystemX<()>> = Box::new(func);
   |                                   ^^^^^^^^^^^^^^ the trait `SystemX<()>` is not implemented for `for<'a> fn(&'a ())`
   |
   = help: the trait `SystemX<()>` is not implemented for `for<'a> fn(&'a ())`
           but trait `SystemX<()>` is implemented for it
   = note: required for the cast from `Box<for<'a> fn(&'a ())>` to `Box<dyn SystemX<()>>`

For more information about this error, try `rustc --explain E0277`.

Discovered by oklyth on the rust community discord.

[danielhenrymantilla]

Here is what I'd deem to be a minor reduction of the snippet:

trait Trait {}

impl Trait for ()
where
    for<'never> [u8] : Sized,
{}

impl Trait for ()
where
    for<'never> [i8] : Sized,
{}

fn demo()
where
    for<'maybe> () : Trait,
{}

fn main() {
    demo();
}

What we can see is that, with distinct trivially-false clauses, we can get overlapping impls on a given type (e.g., ()). Since they're all false, once required to be true (e.g., in that invocation of demo()¹), we get an error saying that the Trait is not implemented for our () type. But as a help, there exists another syntactical impl of the Trait (even if, semantically, it does not apply), hence why it might be getting picked and suggested.

Footnotes

1. we've needed to delay the checking of the () : Trait bound at fn demo()'s definition, since the diagnostic error for a trivially false bound appears to be a bit different: it does not run into what the OP describes ↩