Can't match strings in consts, but can match byte strings in consts

[clarfonthey]

Basically, this feels like an artifical restriction due to the fact that both str::as_bytes and matching on byte strings is possible in constants:

Playground link

const fn byte_string_workaround(x: &str) -> u8 {
    match x.as_bytes() {
        b"hello" | b"world" => 1,
        b"goodbye" | b"nonworld" => 2,
        _ => 3,
    }
}

const fn string_failure(x: &str) -> u8 {
    match x {
        "hello" | "world" => 1,
        "goodbye" | "nonworld" => 2,
        _ => 3,
    }
}

Note that byte_string_workaround compiles fine on stable but string_failure returns an error saying that strings can't be matched in constants.

[JonathanBrouwer]

Internally, this seems to be caused by that a match on &str calls <str as PartialEq>::eq, whereas a match on &[u8] does not call <&[u8] as PartialEq>::eq, since matching on slices generates different code.
This is not very easy to fix, unless we compile matching on strs differently.

[clarfonthey]

That honestly feels wrong, since it's quite surprising that byte slices and strings have entirely different code for matching. Although in this case, it may be more difficult to fix by going the other way around: if it's for performance, then byte slices should still be specialised to use the same code as strings, which might cause compatibility hazards until eq in constants is stable.

It feels like using eq internally for strings shouldn't be too hard to get around, though, since it's not generic over all types and can just be replaced by a separate const fn specific to strings.