make cfg_select a builtin macro

[folkertdev]

tracking issue: #115585

This parses mostly the same as the macro cfg_select version, except:

1. wrapping in double brackets is no longer supported (or needed): cfg_select {{ /* ... */ }} is now rejected.
2. in an expression context, the rhs is no longer wrapped in a block, so that this now works:

fn main() {
    println!(cfg_select! {
        unix => { "foo" }
        _ => { "bar" }
    });
}

3. a single wildcard rule is now supported: cfg_select { _ => 1 } now works

I've also added an error if none of the rules evaluate to true, and warnings for any arms that follow the _ wildcard rule.

cc @traviscross if I'm missing any feature that should/should not be included
r? @petrochenkov for the macro logic details

[folkertdev]

I'd love to know if there is already a standard way to expand a token stream. I couldn't find one, so I did some refactoring here.

[rustbot]

These commits modify the Cargo.lock file. Unintentional changes to Cargo.lock can be introduced when switching branches and rebasing PRs.

If this was unintentional then you should revert the changes before this PR is merged.
Otherwise, you can ignore this comment.

This PR modifies tests/auxiliary/minicore.rs.

cc @jieyouxu

[traviscross]

The behavior, per the tests and the impl, looks correct to me.

[folkertdev]

I moved some things around (analogously to asm!) so that rustfmt can use the parsed representation of cfg_select!. Now that it is a builtin macro, I'm assuming formatting won't work and becomes a blocker for stabilization. I think the formatting rules are reasonably straightforward though.

Implementation-wise the one thing I'm not sure about is how to get rustfmt to format a TokenStream that represents the rhs of an arm. It gets expanded based on the context (can be an item, expr, stmt, etc.). But hopefully the rustfmt folks know how to deal with that.

[traviscross]

cc @rust-lang/rustfmt @rust-lang/style

[folkertdev]

This is the relevant file for rustfmt: the parse_cfg_select function returns a CfgSelectBranches that keeps (as far as I can tell) all of the structure that is required to format cfg_select.

A cfg_select looks like this

fn print() {
    println!(cfg_select! {
        unix => { "unix" }
        _ => { "not unix" }
    });
}

where the right-hand side of the arrow is a TokenTree. That token tree is expanded based on the context: if the macro is in expression position, it'll be parsed as an expression, similarly for statements, items and any other position where a macro can occur.

So the formatter heeds to handle this TokenTree (really a TokenStream after we strip of the outer braces) somehow. I didn't see immediately how to do that given the existing APIs, but I assume it's possible because macros-by-example would need the same thing.

[bors]

☔ The latest upstream changes (presumably #143521) made this pull request unmergeable. Please resolve the merge conflicts.