rust/tests/ui/pattern/usefulness/issue-30240.rs

fn main() {
    match "world" { //~ ERROR non-exhaustive patterns: `&_`
        "hello" => {}
    }

    match "world" { //~ ERROR non-exhaustive patterns: `&_`
        ref _x if false => {}
        "hello" => {}
    }
}
handle string literals correctly in match checking The root of the problem is that a string literal pattern is essentially of the form `&LITERAL`, in a single block, while match checking wants to split that. To fix that, I added a type field to the patterns in match checking, which allows us to distinguish between a full and split pattern. That file is ugly and needs to be cleaned. However, `trans::_match` calls it, so I think we should delay the cleanup until we kill that. Fixes #30240 2016-06-05 15:56:11 -05:00			`fn main() {`
Fix #78549 Before #78430, string literals worked because `specialize_constructor` didn't actually care too much which constructor was passed to it unless needed. Since then, string literals are special cased and a bit hacky. I did not anticipate patterns for the `&str` type other than string literals, hence this bug. This makes string literals less hacky. 2020-10-31 20:58:48 -05:00			match "world" { //~ ERROR non-exhaustive patterns: `&_`
handle string literals correctly in match checking The root of the problem is that a string literal pattern is essentially of the form `&LITERAL`, in a single block, while match checking wants to split that. To fix that, I added a type field to the patterns in match checking, which allows us to distinguish between a full and split pattern. That file is ugly and needs to be cleaned. However, `trans::_match` calls it, so I think we should delay the cleanup until we kill that. Fixes #30240 2016-06-05 15:56:11 -05:00			`"hello" => {}`
			`}`

Fix #78549 Before #78430, string literals worked because `specialize_constructor` didn't actually care too much which constructor was passed to it unless needed. Since then, string literals are special cased and a bit hacky. I did not anticipate patterns for the `&str` type other than string literals, hence this bug. This makes string literals less hacky. 2020-10-31 20:58:48 -05:00			match "world" { //~ ERROR non-exhaustive patterns: `&_`
handle string literals correctly in match checking The root of the problem is that a string literal pattern is essentially of the form `&LITERAL`, in a single block, while match checking wants to split that. To fix that, I added a type field to the patterns in match checking, which allows us to distinguish between a full and split pattern. That file is ugly and needs to be cleaned. However, `trans::_match` calls it, so I think we should delay the cleanup until we kill that. Fixes #30240 2016-06-05 15:56:11 -05:00			`ref _x if false => {}`
			`"hello" => {}`
			`}`
			`}`