Bindings does not simplify programming

[3442853561]

fn main() {
    let foo = "1 + (2 + 3)";
    for ch in foo.chars() {
        match ch {
            e @ '(' | e @ '[' | e @ '{' => match e {
                '(' => {}
                '[' => {}
                '{' => {}
                // As we all know, there is missing a _
                // However I think the compiler should be smarter
                // Because there is a binding
            },
            _ => {}
        }
    }
}

As we all know, there is missing a _
However I think the compiler should be smarter
Because there is a binding here
There may be code that will never be executed

[lambda]

There may be code that will never be executed

The right way to express this is _ => unreachable!().

It would be nice if the compiler would be smarter in this case, but there will always be some cases in which the compiler is not smart enough to figure something out, so you can use unreachable!() to explicitly denote impossible cases.

[crlf0710]

It would be nice if the compiler would be smarter in this case, but there will always be some cases in which the compiler is not smart enough to figure something out, so you can use unreachable!() to explicitly denote impossible cases.

However, sometimes it's hard if not impossible for people to estimate how smart the compiler is, or would be in the future. See #45414 for an example. It would be great if there's a solid and compatible "check condition", so people would know whether an "unreachable!()" is necessary and won't raise such warnings.

[Mark-Simulacrum]

I'm going to go ahead and close this as it's not entirely clear that this would be something we'd want to implement; I think extending the compiler lints to be able to detect this would be an interesting avenue to explore but are quite hard and not entirely clear -- as well as almost impossible to close out entirely.