Macro problem in enum

[mosheng]

I don't understand why this doesn't work properly? Or do I have to write them all by hand? I'm trying to write a toy RISC V VM, but I feel that the way to process the instructions is too complicated (and the RISC V instruction set itself has a relatively fixed structure).

Syntax Error: expected COMMArust-analyzersyntax-error
Syntax Error: expected enum variantrust-analyzersyntax-error
Syntax Error: expected COMMArust-analyzersyntax-error
Syntax Error: expected enum variantrust-analyzersyntax-error
Syntax Error: expected COMMArust-analyzersyntax-error

macro_rules! r_type {
    ( $( $name:ident ),* ) => {
        $(
            #[doc = concat!("R型指令: ", stringify!($name))]
            $name {
                rd: String,
                rs1: String,
                rs2: String,
            },
        )*
    };
}

macro_rules! i_type {
    ( $( $name:ident ),* ) => {
        $(
            #[doc = concat!("I型指令: ", stringify!($name))]
            $name {
                rd: String,
                rs1: String,
                rs2: i64,
            },
        )*
    };
}

macro_rules! u_type {
    ( $( $name:ident ),* ) => {
        $(
            #[doc = concat!("U型指令: ", stringify!($name))]
            $name {
                rd: String,
                rs1: i64,
            },
        )*
    };
}
enum Instruction {
    // R 型
    r_type!(ADD, SUB, SLT, SLTU, AND, OR, XOR, SLL, SRL, SRA, MUL);

    // I 型
    i_type!(ADDI, SLTI, SLTIU, ANDI, ORI, XORI, SLLI, SRLI, SRAI);

    // U 型
    u_type!(LUI, AUIPC);

    // 伪指令
    SEQZ { rd: String, rs1: String },
    NOP,
    MV { rd: String, rs1: String },
    NOT { rd: String, rs1: String },
    Li { rd: String, rs1: i64 },
}

[nerditation]

an enum variant is not a valid position for a macro invocation. valid positions includes: expressions, statements, patterns, types, items.

[mosheng]

So I have no choice but to write them one by one by hand? ok, alright ...

[crispycat]

Trying this code in the playground I get the following:

error: unexpected token: `!`
  --> src/lib.rs:40:11
   |
40 |     r_type!(ADD, SUB, SLT, SLTU, AND, OR, XOR, SLL, SRL, SRA, MUL);
   |           ^ unexpected token after this
   |
   = note: macros cannot expand to enum variants

Why not create structs to represent the common data, like this:

struct RTypeData {
    rd: String,
    rs1: String,
    rs2: String
}

struct ITypeData {
    rd: String,
    rs1: String,
    rs2: i64
}

struct UTypeData {
    rd: String,
    rs1: i64
}

enum Instruction {
    // R 型
    /// R型指令: ADD
    ADD(RTypeData),
    /// R型指令: SUB
    SUB(RTypeData),
    /// R型指令: SLT
    SLT(RTypeData),
    /// R型指令: SLTU
    SLTU(RTypeData),
    /// R型指令: AND
    AND(RTypeData),
    /// R型指令: OR
    OR(RTypeData),
    /// R型指令: XOR
    XOR(RTypeData),
    /// R型指令: SLL
    SLL(RTypeData),
    /// R型指令: SRL
    SRL(RTypeData),
    /// R型指令: SRA
    SRA(RTypeData),
    /// R型指令: MUL
    MUL(RTypeData),

    // I 型
    /// I型指令: ADDI
    ADDI(ITypeData),
    /// I型指令: SLTI
    SLTI(ITypeData),
    /// I型指令: SLTIU
    SLTIU(ITypeData),
    /// I型指令: ANDI
    ANDI(ITypeData),
    /// I型指令: ORI
    ORI(ITypeData),
    /// I型指令: XORI
    XORI(ITypeData),
    /// I型指令: SLLI
    SLLI(ITypeData),
    /// I型指令: SRLI
    SRLI(ITypeData),
    /// I型指令: SRAI
    SRAI(ITypeData),
    
    // U 型
    /// U型指令: LUI
    LUI(UTypeData),
    /// U型指令: AUIPC
    AUIPC(UTypeData),

    // 伪指令
    SEQZ { rd: String, rs1: String },
    NOP,
    MV { rd: String, rs1: String },
    NOT { rd: String, rs1: String },
    Li { rd: String, rs1: i64 },
}

Playground: Rust Playground

[mosheng]

Indeed, it seems like a good choice.

[nerditation]

@mosheng

So I have no choice but to write them one by one by hand?

it depends on how crazy you want to go with macros, how robust you want the parsing to be, and also how well the the syntax was designed for the custom DSL.

use the Tools button then Expand Macros to see the expanded code:

Rust Playground

[mosheng]

Damn, this is the craziest and most powerful macro writing method I have ever seen.I can't express my shock, but I admire you.

[mosheng]

Additional supplement, because my demand code is basically similar to this structure.

pub enum Instruction {}

impl Instruction {}

mod test {}

I think this is very unified. This framework is so unified. I think your solution is the best, you can use multiple small macros to splice into a large macro. Thank you very much for your inspiration.

[mosheng]

The last information supplement, according to nerditationInspired by this, I finally got the solution. I'll share it with you for your reference (in case anyone is interested? Whatever)

Rust Playground