Confusing Error Message with Impl Trait in E0308

[WalkerCodeRanger]

While trying out the new impl trait feature #34511, I wrote some incorrect code. The error message was confusing to me. I've simplified the code and in the process found a very similar error message that is much clearer. My example shows both.

The code (which can be run in the playground on nightly):

#![feature(conservative_impl_trait)]

use std::iter;

fn mask<T: Iterator<Item = i32>>(iter: T) -> impl Iterator<Item = i32> {
    return iter;
}

// this compile error clearly indicated the role of the impl trait
fn test_clear_error_message(condition: bool) -> impl Iterator<Item = i32> {
    if condition {
        mask(iter::once(23))
    } else {
        mask(1..23)
    }
}

// this error message is confusing because the compiler has inferred through
// the impl trait, but gives no indication it has done so
fn test_confusing_error_message(condition: bool) -> impl Iterator<Item = i32> {
    if condition {
        return mask(iter::once(23));
    }
    mask(1..23)
}

fn main() {
    test_clear_error_message(true);
    test_confusing_error_message(true);
}

The first error message is clear. It indicates that impl trait types are involved and that it has figured out what their underlying types are with this nice notation `impl std::iter::Iterator` (struct `std::iter::Once`).

error[E0308]: if and else have incompatible types
  --> src/main.rs:11:5
   |
11 | /     if condition {
12 | |         mask(iter::once(23))
13 | |     } else {
14 | |         mask(1..23)
15 | |     }
   | |_____^ expected struct `std::iter::Once`, found struct `std::ops::Range`
   |
   = note: expected type `impl std::iter::Iterator` (struct `std::iter::Once`)
              found type `impl std::iter::Iterator` (struct `std::ops::Range`)

The second error message is the confusing one. I understand that the compiler has inferred the types and that the types the error message names are not impl trait types. However, it's surprising that the real types are leaking out. I feel like the error message needs to indicate that the inference has passed through the impl trait types. I imagine that something similar could happen in a case where one of the two types was coming from code in a third-party crate. That would be very confusing.

error[E0308]: mismatched types
  --> src/main.rs:24:10
   |
24 |     mask(1..23)
   |          ^^^^^ expected struct `std::iter::Once`, found struct `std::ops::Range`
   |
   = note: expected type `std::iter::Once<i32>`
              found type `std::ops::Range<{integer}>`

Compiler Version

>rustc --version --verbose
rustc 1.25.0-nightly (3ec5a99aa 2018-02-14)
binary: rustc
commit-hash: 3ec5a99aaa0084d97a9e845b34fdf03d1462c475
commit-date: 2018-02-14
host: x86_64-pc-windows-msvc
release: 1.25.0-nightly
LLVM version: 6.0

[Gisleburt]

I was about to file a seperate report (glad I checked).

Code to reproduce

use std::time::{SystemTime, UNIX_EPOCH};

fn get_name() -> impl ToString {
    let time = SystemTime::now();
    let timestamp = time.duration_since(UNIX_EPOCH).unwrap().as_secs();
    if  timestamp % 2 == 0 {
        variant1()
    } else {
        variant2()
    }
}

fn variant1() -> impl ToString {
    ", World".to_string()
}

fn variant2() -> impl ToString {
    " World".to_string()
}

fn main() {
    println!("Hello{}!", get_name().to_string());
}

Output

error[E0308]: if and else have incompatible types
  --> src/main.rs:6:5
   |
6  | /     if  timestamp % 2 == 0 {
7  | |         variant1()
8  | |     } else {
9  | |         variant2()
10 | |     }
   | |_____^ expected anonymized type, found a different anonymized type
   |
   = note: expected type `impl std::string::ToString` (anonymized type)
              found type `impl std::string::ToString` (anonymized type)

error: aborting due to previous error

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

The code works if you only return from one function, eg:

fn get_name() -> impl ToString {
    variant1()
}

I get that the compilor probably can't guarantee the same concrete type.

I'd quite like to do a PR to explain that if thats the way to go. I could expand on E0308, or is there a way to explain it in the above output?

Compilor Version

➜ rustc --version --verbose
rustc 1.27.0 (3eda71b00 2018-06-19)
binary: rustc
commit-hash: 3eda71b00ad48d7bf4eef4c443e7f611fd061418
commit-date: 2018-06-19
host: x86_64-apple-darwin
release: 1.27.0
LLVM version: 6.0

[estebank]

Current output:

error[E0308]: if and else have incompatible types
  --> src/main.rs:14:9
   |
11 | /     if condition {
12 | |         mask(iter::once(23))
   | |         -------------------- expected because of this
13 | |     } else {
14 | |         mask(1..23)
   | |         ^^^^^^^^^^^ expected struct `std::iter::Once`, found struct `std::ops::Range`
15 | |     }
   | |_____- if and else have incompatible types
   |
   = note: expected type `impl std::iter::Iterator` (struct `std::iter::Once`)
              found type `impl std::iter::Iterator` (struct `std::ops::Range`)

error[E0308]: mismatched types
  --> src/main.rs:24:10
   |
24 |     mask(1..23)
   |          ^^^^^ expected struct `std::iter::Once`, found struct `std::ops::Range`
   |
   = note: expected type `std::iter::Once<i32>`
              found type `std::ops::Range<{integer}>`

error: aborting due to 2 previous errors

[estebank]

Current output:

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:14:9
   |
5  |   fn mask<T: Iterator<Item = i32>>(iter: T) -> impl Iterator<Item = i32> {
   |                                                ------------------------- the found opaque type
...
11 | /     if condition {
12 | |         mask(iter::once(23))
   | |         -------------------- expected because of this
13 | |     } else {
14 | |         mask(1..23)
   | |         ^^^^^^^^^^^ expected struct `std::iter::Once`, found struct `std::ops::Range`
15 | |     }
   | |_____- `if` and `else` have incompatible types
   |
   = note:     expected type `impl Iterator` (struct `std::iter::Once`)
           found opaque type `impl Iterator` (struct `std::ops::Range`)
help: you could change the return type to be a boxed trait object
   |
10 | fn test_clear_error_message(condition: bool) -> Box<dyn Iterator<Item = i32>> {
   |                                                 ~~~~~~~                     +
help: if you change the return type to expect trait objects, box the returned expressions
   |
12 ~         Box::new(mask(iter::once(23)))
13 |     } else {
14 ~         Box::new(mask(1..23))
   |

error[E0308]: mismatched types
  --> src/main.rs:24:10
   |
24 |     mask(1..23)
   |          ^^^^^ expected struct `std::iter::Once`, found struct `std::ops::Range`
   |
   = note: expected struct `std::iter::Once<i32>`
              found struct `std::ops::Range<{integer}>`

[Gisleburt]

It's worth saying that in my example, the output has also changed.

The explanation is still confusing, but it now makes a suggestion and that suggestion works.

Original:

use std::time::{SystemTime, UNIX_EPOCH};

fn get_name() -> impl ToString {
    let time = SystemTime::now();
    let timestamp = time.duration_since(UNIX_EPOCH).unwrap().as_secs();
    if  timestamp % 2 == 0 {
        variant1()
    } else {
        variant2()
    }
}

fn variant1() -> impl ToString {
    ", World".to_string()
}

fn variant2() -> impl ToString {
    " World".to_string()
}

fn main() {
    println!("Hello{}!", get_name().to_string());
}

Output as of rustc 1.56.1:

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:9:9
   |
6  | /     if  timestamp % 2 == 0 {
7  | |         variant1()
   | |         ---------- expected because of this
8  | |     } else {
9  | |         variant2()
   | |         ^^^^^^^^^^ expected opaque type, found a different opaque type
10 | |     }
   | |_____- `if` and `else` have incompatible types
...
17 |   fn variant2() -> impl ToString {
   |                    ------------- the found opaque type
   |
   = note:     expected type `impl ToString` (opaque type at <src/main.rs:13:18>)
           found opaque type `impl ToString` (opaque type at <src/main.rs:17:18>)
   = note: distinct uses of `impl Trait` result in different opaque types
help: you could change the return type to be a boxed trait object
   |
3  | fn get_name() -> Box<dyn ToString> {
   |                  ~~~~~~~         +
help: if you change the return type to expect trait objects, box the returned expressions
   |
7  ~         Box::new(variant1())
8  |     } else {
9  ~         Box::new(variant2())
   |

For more information about this error, try `rustc --explain E0308`.
error: could not compile `e0308` due to previous error

After implementing suggestions:

use std::time::{SystemTime, UNIX_EPOCH};

fn get_name() -> Box<dyn ToString> {
    let time = SystemTime::now();
    let timestamp = time.duration_since(UNIX_EPOCH).unwrap().as_secs();
    if  timestamp % 2 == 0 {
        variant1()
    } else {
        variant2()
    }
}

fn variant1() -> Box<dyn ToString> {
    Box::new(", World".to_string())
}

fn variant2() -> Box<dyn ToString> {
    Box::new(" World".to_string())
}

fn main() {
    println!("Hello{}!", get_name().to_string());
}

Output:

cargo run
   Compiling e0308 v0.1.0 (/Users/daniel.mason/projects/e0308)
    Finished dev [unoptimized + debuginfo] target(s) in 1.43s
     Running `target/debug/e0308`
Hello, World!

(Yes, I did name the project e0308)

Edit: I accidentally copied in an intermediate output, so I corrected this

[estebank]

Current output:

error[E0308]: mismatched types
  --> src/main.rs:24:10
   |
24 |     mask(1..23)
   |     ---- ^^^^^ expected struct `Once`, found struct `Range`
   |     |
   |     arguments to this function are incorrect
   |
   = note: expected struct `std::iter::Once<i32>`
              found struct `std::ops::Range<{integer}>`
note: function defined here
  --> src/main.rs:5:4
   |
5  | fn mask<T: Iterator<Item = i32>>(iter: T) -> impl Iterator<Item = i32> {
   |    ^^^^                          -------

We still need to provide a similar suggestion to the if/else/match case.

[estebank]

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:12:9
   |
3  |   fn mask<T: Iterator<Item = i32>>(iter: T) -> impl Iterator<Item = i32> {
   |                                                -------------------------
   |                                                |
   |                                                the expected opaque type
   |                                                the found opaque type
...
9  | /     if condition {
10 | |         mask(iter::once(23))
   | |         -------------------- expected because of this
11 | |     } else {
12 | |         mask(1..23)
   | |         ^^^^^^^^^^^ expected `std::iter::Once<i32>`, found `std::ops::Range<i32>`
13 | |     }
   | |_____- `if` and `else` have incompatible types
   |
   = note: expected opaque type `impl Iterator<Item = i32>` (`std::iter::Once<i32>`)
              found opaque type `impl Iterator<Item = i32>` (`std::ops::Range<i32>`)
   = note: distinct uses of `impl Trait` result in different opaque types
help: you could change the return type to be a boxed trait object
   |
8  | fn test_clear_error_message(condition: bool) -> Box<dyn Iterator<Item = i32>> {
   |                                                 ~~~~~~~                     +
help: if you change the return type to expect trait objects, box the returned expressions
   |
10 ~         Box::new(mask(iter::once(23)))
11 |     } else {
12 ~         Box::new(mask(1..23))
   |

error[E0308]: mismatched types
  --> src/main.rs:22:10
   |
22 |     mask(1..23)
   |     ---- ^^^^^ expected `Once<i32>`, found `Range<{integer}>`
   |     |
   |     arguments to this function are incorrect
   |
   = note: expected struct `std::iter::Once<i32>`
              found struct `std::ops::Range<{integer}>`
help: the return type of this call is `std::ops::Range<{integer}>` due to the type of the argument passed
  --> src/main.rs:22:5
   |
22 |     mask(1..23)
   |     ^^^^^-----^
   |          |
   |          this argument influences the return type of `mask`
note: function defined here
  --> src/main.rs:3:4
   |
3  | fn mask<T: Iterator<Item = i32>>(iter: T) -> impl Iterator<Item = i32> {
   |    ^^^^                          -------