Specializations and negative traits are resolved in a wrong way.

[wdanilo]

Hi, consider the following code:

#![feature(specialization)]
#![feature(optin_builtin_traits)]

use std::ops::Deref;
use std::ops::DerefMut;

// =================
// === WithLabel ===
// =================

struct WithLabel<T>(String, T);

auto trait IsNotWithLabel {}
impl<T> !IsNotWithLabel for WithLabel<T> {}

pub trait HasLabel {
    fn label(&self) -> &String;
}

impl<T> HasLabel for WithLabel<T> {
    fn label(&self) -> &String { 
        &self.0
    }
}

impl<T> HasLabel for T
where T: Deref + IsNotWithLabel, <Self as Deref>::Target : HasLabel {
    default fn label(&self) -> &String { 
        self.deref().label() 
    }
}

impl<T> Deref for WithLabel<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.1
    }
}

// ==============
// === WithID ===
// ==============

struct WithID<T>(i32, T);

pub trait HasID {
    fn id(&self) -> &i32;
}

impl<T> HasID for WithID<T> {
    fn id(&self) -> &i32 { 
        &self.0
    }
}

auto trait IsNotWithID {}
impl<T> !IsNotWithID for WithID<T> {}

impl<T> HasID for T
where T: Deref + IsNotWithID, <Self as Deref>::Target : HasID {
    default fn id(&self) -> &i32 { 
        self.deref().id() 
    }
}

impl<T> Deref for WithID<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.1
    }
}

// =============
// === Usage ===
// =============

struct A(i32);

type X = WithLabel<WithID<A>>;

fn test<T: HasID + HasLabel> (t: T) {
    println!("{:?}", t.label());
    println!("{:?}", t.id());
}

fn main() {
    let v1 = WithLabel("label1".to_string(), WithID(0, A(1)));
    // test(v1); // THIS DOES NOT COMPILE
}

Everything compiles fine, but the last line (commented out). The error is:

error[E0277]: the trait bound `WithID<A>: IsNotWithID` is not satisfied in `WithLabel<WithID<A>>`
  --> src/main.rs:88:10
   |
81 | fn test<T: HasID + HasLabel> (t: T) {
   |    ----    ----- required by this bound in `test`
...
88 |     test(v1);
   |          ^^ within `WithLabel<WithID<A>>`, the trait `IsNotWithID` is not implemented for `WithID<A>`
   |
   = help: the following implementations were found:
             <WithID<T> as IsNotWithID>
   = note: required because it appears within the type `WithLabel<WithID<A>>`
   = note: required because of the requirements on the impl of `HasID` for `WithLabel<WithID<A>>`

And this is not correct. The type of v1 is WithLabel<WithID<A>>. When passing it to test we must prove that WithLabel<WithID<A>> : HasID + HasLabel. Let's start with HasID:

• The impl<T> HasID for WithID<T> is obviously not matched.
• The impl<T> HasID for T is matched, including it's constraints: T: Deref + IsNotWithID, and <Self as Deref>::Target : HasID, because Target resolves to WithID<A> and there is only 1 instance that matches WithID<A>: HasID.

The constraint WithLabel<WithID<A>> : HasLabel is simple to be checked – only the impl<T> HasLabel for WithLabel<T> is matched here.

[qnighy]

A type T is Send if and only if its all field types are Send, except cases where it (shallow-)matches to any explicit implementation. The same rule applies to IsNotWithID, which is an auto trait.

In this case, to resolve WithLabel<WithID<A>>: HasID, the blanket impl is used. The blanket impl requires WithLabel<WithID<A>>: IsNotWithID. It doesn't match any explicit implementation, so the default rule is applied.

WithLabel<WithID<A>> has two fields: String and WithID<A>. Both have to be IsNotWithID. WithID<A>: IsNotWithID is negated by the explicit negative implementation. Therefore this obligation isn't satisfied.

[wdanilo]

@qnighy thank you for the reply!

WithLabel<WithID<A>> has two fields: String and WithID<A>. Both have to be IsNotWithID.

Why is that? Why the constraint WithLabel<WithID<A>>: IsNotWithID propagates to both fields of WithLabel? As far as I am aware, the auto trait IsNotWithID {} is matched here, which should not bring any new constraints to the scope, right?

[wdanilo]

Oh, I just found the answer: https://doc.rust-lang.org/nightly/unstable-book/language-features/optin-builtin-traits.html

Auto traits, like Send or Sync in the standard library, are marker traits that are automatically implemented for every type, unless the type, or a type it contains, has explicitly opted out via a negative impl.

Ok, this naming / syntax is confusing. In such a case this topic can be closed and we can continue discussion about structs extending other structs here: #31844