async fn presence affects an unrelated error message

[tguser402]

The following code

trait Test<T> {
    fn is_some(self: T);
}

fn f() {
    let x = Some(2);
    if x.is_some() {
        println!("Some");
    }
}

produces an expected error:

error[E0307]: invalid `self` parameter type: T
 --> src/lib.rs:2:22
  |
2 |     fn is_some(self: T);
  |                      ^
  |
  = note: type of `self` must be `Self` or a type that dereferences to it
  = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)

If I make f async,

trait Test<T> {
    fn is_some(self: T);
}

async fn f() {
    let x = Some(2);
    if x.is_some() {
        println!("Some");
    }
}

the original error is replaced with this:

error[E0308]: mismatched types
 --> src/lib.rs:7:8
  |
7 |     if x.is_some() {
  |        ^^^^^^^^^^^ expected bool, found ()
  |
  = note: expected type `bool`
             found type `()`

Meta

rustc --version --verbose:

rustc 1.39.0 (4560ea788 2019-11-04)
binary: rustc
commit-hash: 4560ea788cb760f0a34127156c78e2552949f734
commit-date: 2019-11-04
host: x86_64-unknown-linux-gnu
release: 1.39.0
LLVM version: 9.0

[jonas-schievink]

Nominating because:

• The trait impl does not exist, the compiler hallucinated it into existence
• Inherent methods are supposed to take precedence over trait methods

This might indicate a quite serious bug in the compiler.

[Centril]

I would suggest stable- and beta-nominating the fix for this PR; it seems like this could warrant a point release. cc @rust-lang/release @rust-lang/lang

[pietroalbini]

@rustbot modify labels: beta-nominated stable-nominated

[Centril]

Phew; looks like precedence works correctly in non-error code at least:

trait Test {
    fn is_some(&self) -> u8;
}

impl<T> Test for Option<T> {
    fn is_some(&self) -> u8 {
        self.is_some() as u8
    }
}

async fn f() {
    let x = Some(2);
    let _: () = x.is_some(); // type is bool.
}

Crisis averted? :)

[nikomatsakis]

@rustbot assign @csmoe

[pnkfelix]

unnominating for back ports; we don't backport nominate issues, just Pull Requests.

[nikomatsakis]

@rfcbot claim

I'll take a look, since @csmoe is finding this to be mighty tricky to track down

[tguser402]

I managed to get similar symptoms without async but with #![feature(arbitrary_self_types)]. But this time the trait compiles.

#![feature(arbitrary_self_types)]
trait Test<T: core::ops::Deref<Target = Self>> {
    fn is_some(self: T);
}

fn f() {
    let x = Some(2);
    if x.is_some() {
        println!("Some");
    }
}

Playground link

error[E0277]: the trait bound `std::option::Option<{integer}>: std::ops::Deref` is not satisfied
 --> src/lib.rs:8:10
  |
8 |     if x.is_some() {
  |          ^^^^^^^ the trait `std::ops::Deref` is not implemented for `std::option::Option<{integer}>`

error[E0308]: mismatched types
 --> src/lib.rs:8:8
  |
8 |     if x.is_some() {
  |        ^^^^^^^^^^^ expected `bool`, found `()`

error: aborting due to 2 previous errors

[nikomatsakis]

I am 99% sure that the diagnosis I posted on #67651 also applies here.

[nikomatsakis]

The async case is fixed by #68884, I think we should break out the arbitrary self types case into a distinct bug.