Cannot use => inside the body of a macro_rules for defining match arms

[TapGhoul]

I tried this code:

enum MyEnum {
    A(i32),
    B(i32),
    C(i32)
}

macro_rules! broken {
    ($n:ident) => { MyEnum::$n(n) => n }
}

fn main() {
    let e = MyEnum::A(1);
    
    match e {
        broken!(A),
        broken!(B),
        broken!(C),
    }
}

Cargo expand output

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
enum MyEnum {
    A(i32),
    B(i32),
    C(i32),
}
fn main() {
    let e = MyEnum::A(1);
    match e {}
}

I expected to see this happen: It compiles successfully, generating my match arms.

Instead, this happened: Match arms are eaten in macro expansion (according to intellij-rust, as cargo-expand doesn't even show anything) - if I wrap the arm in () within the macro definition (i.e. (a => b)), it works, but this is not a valid match arm.

My understanding is that the macro is getting confused with the pattern:

macro_rules! my_macro {
    () => { () => {} }
}

It appears to see ) => { ( as a pattern

Meta

rustc --version --verbose:

rustc 1.71.0 (8ede3aae2 2023-07-12)
binary: rustc
commit-hash: 8ede3aae28fe6e4d52b38157d7bfe0d3bceef225
commit-date: 2023-07-12
host: x86_64-unknown-linux-gnu
release: 1.71.0
LLVM version: 16.0.5

Backtrace

❯ RUST_BACKTRACE=1 cargo build
   Compiling qwe v0.1.0 (/home/silvea/qwe)
error: unexpected `,` in pattern
  --> src/main.rs:15:19
   |
15 |         broken!(A),
   |                   ^
   |
help: try adding parentheses to match on a tuple...
   |
15 ~         (broken!(A),
16 |         broken!(B),
17 ~         broken!(C),)
   |
help: ...or a vertical bar to match on multiple alternatives
   |
15 ~         broken!(A) |
16 +         broken!(B) |
17 +         broken!(C) |
   |

warning: unused macro definition: `broken`
 --> src/main.rs:7:14
  |
7 | macro_rules! broken {
  |              ^^^^^^
  |
  = note: `#[warn(unused_macros)]` on by default

warning: `qwe` (bin "qwe") generated 1 warning
error: could not compile `qwe` (bin "qwe") due to previous error; 1 warning emitted

[PatchMixolydic]

Relevant output:

error: unexpected `,` in pattern
  --> src/lib.rs:19:55
   |
19 |         config_opt!(DoubleWaterfall, double_waterfall),
   |                                                       ^
   |
help: try adding parentheses to match on a tuple...
   |
19 ~         (config_opt!(DoubleWaterfall, double_waterfall),
20 ~         config_opt!(RoundRobin, round_robin),)
   |
help: ...or a vertical bar to match on multiple alternatives
   |
19 ~         config_opt!(DoubleWaterfall | double_waterfall) |
20 +         config_opt!(RoundRobin | round_robin) |
   |

According to the Rust Reference, macros are not permitted to expand to match arms, but they are allowed to expand to patterns. Therefore, while parsing this match expression:

match config {
    LoadBalancerConfig::BlackHole => Self::BlackHole,
    config_opt!(DoubleWaterfall, double_waterfall),
    config_opt!(RoundRobin, round_robin),
}

... the parser interprets the first config_opt! call as a pattern, then tries to consume either |, if, or =>. Since it finds none of those, it emits a diagnostic.

There should probably be a targeted diagnostic for macro invocation patterns followed by a comma in match expressions:

error: unexpected `,` in pattern
  --> src/lib.rs:19:55
   |
19 |         config_opt!(DoubleWaterfall, double_waterfall),
   |                                                       ^
   |
   = note: macros cannot expand to match arms

[TapGhoul]

Ah, balls, my bad. I'll leave the issue open for the purpose of a diagnostic.

[fmease]

@rustbot label -needs-triage -C-bug T-compiler A-parser A-diagnostics A-macros D-terse