Constants involving dereferencing in pattern matching

[IvanUkhov]

Constants that dereference string literals cannot be currently used for pattern matching as show below:

const A: [u8; 4] = *b"fooo";

fn main() {
    match *b"xxxx" {
        A => {},
        _ => {}
    }
}

Such constants can be used in other contexts without any problem. It is inconsistent, and a very prominent use case is missing.

A rather easy task for a new compiler hacker (const_eval::const_expr_to_pat).

[barca]

I would love to try take a work on this, plus I would qualify as a new compiler hacker. I've been going through the code linked above, and I have some idea of what to do, although I will undoubtedly have questions later.

@barca Happy to mentor, let me know how it goes! Thanks!

[barca]

@jakub- While I'm fairly confident about the code I've written to solve this issue, However I'm running into the issue of compiling the language from source. Its extremely slow to compile, and quite frustrating when a serious error occurs(which has unfortunately happened quite frequently). I was wondering if you had any tricks for speeding up this overall process. Thanks

[barca]

@jakub- So, I've been struggling with this issue, but have been actively working on it. up until now I have been trying to dereference the u8 literals or the vec that holds them, however have been unsuccessful in this. While it is more than possible that I have made a mistake in my implementation, I was wondering if you had an idea of how to approach this issue.

[brson]

@pnkfelix @eddyb @nrc Any suggestions on how to proceed here? @barca posting your patch would probably help.

[nrc]

@barca on slow compiles, there's a few things you can do, make sure you're building with -j8 (you'll have to experiment with the exact number of jobs to find the optimal number for your machine) and only build the stage1 compiler (make rustc-stage1) rather than the full bootstrap. You can then test using the stage1 build and only do a full bootstrap when you are happy with your work. Other than that, long build times are just part of life for rust compiler hackers, sorry.

[nrc]

@barca please post your patch and I'll take a look, hard for me to know exactly what the problem is without seeing the code.

[barca]

@nrc thanks, I was able to find some blogs, I've been doing 4 jobs seems to work fast enough.
here's my code. I could be very wrong in my approach, and would appreciate any advice.

[nrc]

@barca I think you're pretty much on the right track. The pattern you end up with should be a PatLit wrapping an ExprVec, then you just need to convert your Vec of u8s into a Vec of LitInts (wrapped in ExprInts). There will be a little bit of a dance with P(..) to do that. Does that get you unstuck?

[barca]

@nrc thats very helpful, thanks so much. people like you and @brson make me love rust!

[nrc]

❤️

@barca ping me on irc if you need any more help

[istaheev]

I came accross this issue and got stuck on it as an inexperienced Rust user. From my understanding the piece of code mentioned in the issue should be equal to the next one where I substitute the constant's value directly into the pattern:

fn main() {
    match *b"xxxx" {
        *b"fooo" => {},
        _ => {}
    }
}

It fails with

<anon>:3:9: 3:10 error: unexpected token: `*`
<anon>:3         *b"fooo" => {},

which means (as far as I understand) that it is not enough to just add constant-to-pattern expansion but also modify match to support matching of dereferenced literals. Is it so or I missed something?