Incorrect "match arms have incompatible types" error message

[offlinemark]

I have code that matches on a Result<usize>, with cases for Ok(usize_var) and Err(why). I get a "match arms have incompatible types" error upon compilation which I believe is incorrect.

I'm not incredibly experienced with this, but discussion in irc (https://botbot.me/mozilla/rust/2015-04-06/?msg=35985521&page=37) supports that this may be a bug.

I tried this code (available at http://is.gd/Y00aRi):

fn main() {
    let mut input: String = String::new();
    match std::io::stdin().read_line(&mut input) {
        Ok(bytes_read) => bytes_read,
        Err(why) => panic!("{}", why)
    }
    println!("{}", input);
}

I expected it to compile, however there is a "match arms have incompatible types" error even though I believe the match arms should both be of type usize.

I should note that adding a semicolon after the match causes clean compilation.

[ftxqxd]

(@steveklabnik I don't think the A-diagnostics label is appropriate for this issue. The bug is that this gives an error at all, not that the error message is bad, so perhaps I-wrong would be better?)

[steveklabnik]

I mean, it's a very bad error regardless, but yeah, maybe. I'll add it too.

[offlinemark]

My rustc version, if it helps

$ rustc --verbose --version
rustc 1.0.0-beta (9854143cb 2015-04-02) (built 2015-04-02)
binary: rustc
commit-hash: 9854143cba679834bc4ef932858cd5303f015a0e
commit-date: 2015-04-02
build-date: 2015-04-02
host: x86_64-apple-darwin
release: 1.0.0-beta

[lilyball]

Yielding an error is correct here. The error message is merely misleading.

The core issue here is your first match arm is attempting to evaluate to a usize value, but the entire match statement is not semicolon-terminated. If you replace the panic!() with, say, 42, you get a similar error:

<anon>:3:5: 6:6 error: mismatched types:
 expected `()`,
    found `usize`
(expected (),
    found usize) [E0308]
<anon>:3     match std::io::stdin().read_line(&mut input) {
<anon>:4         Ok(bytes_read) => bytes_read,
<anon>:5         Err(why) => 42
<anon>:6     }

This is also a bit misleading. The error looks like this because the match expression occurs in statement position, so either the match expression needs to resolve to the type () or it needs to be semicolon-terminated. The error here could definitely be better. In your case, the error is about the match arms having different types because Rust apparently decides to unify the panic!() with the expected () return value, instead of with the first match arm's usize value. If it resolved it with the usize then you'd see the error I listed above instead.

[lilyball]

Given that, I'm removing I-wrong.

[ftxqxd]

@kballard Huh, you're right. I always assumed that adding a semicolon to a statement-position match shouldn't ever change anything.

[lilyball]

Funnily enough, just the other day in IRC @bstrie discovered the exact same thing :)

Another interesting test case, by @Binero from #24568, that we should include as part of the fix:

fn main() {
    is_one(1)
}

fn is_one(a: u8) {
    match a {
        1 => true,
        _ => panic!("It's not one!"),
    }
}

<anon>:6:5: 9:6 error: match arms have incompatible types:
 expected `bool`,
    found `()`
(expected bool,
    found ()) [E0308]
<anon>:6     match a {
<anon>:7         1 => true,
<anon>:8         _ => panic!("It's not one!"),
<anon>:9     }
<anon>:8:14: 8:38 note: match arm with an incompatible type
<anon>:8         _ => panic!("It's not one!"),
                      ^~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
playpen: application terminated with error code 101
Program ended.

[rbtcollins]

Just to note, that this is super confusing for new rust developers - I sought help in #rust after beating my head on the wall for a bit :)

[fungos]

Another code that to me looks the same issue or even #35685. But it is a little different so I'm not really sure if should open a new issue:

pub trait Foo {}

struct Bar;
struct Baz;

impl Foo for Bar { }
impl Foo for Baz { }

fn not_all_paths(a: &str) -> u32 {
    match a {
        "baz" => 0,
        _ => 1,
    }; // "not all control paths return a value" due to ;
}

fn right(b: &str) -> Box<Foo> {
    match b {
        "baz" => Box::new(Baz),
        _ => Box::new(Bar),
    }
}

fn wrong(c: &str) -> Box<Foo> {
    match c {
        "baz" => Box::new(Baz),
        _ => Box::new(Bar),
    }; // "match arms have incompatible types" due to ;
}

fn main() {
}

Play here: https://is.gd/GTv1gf
Using: rustc 1.14.0-nightly (7c69b0d 2016-11-01)

[nambrot]

Could someone outline what the recommended approach is for differently typed match arms? What do I do with options where i want to just run a operation in the Some case but ignore in the None case?