Improve macros for inherited enums?

[overlookmotel]

Last bit of unfinished business after oxc-project/oxc#3115...

That PR introduced squashed/inherited enums. The least ergonomic API is for matching, which requires a set of match_* macros e.g.:

match prop_key {
    PropertyKey::StaticIdentifier(id) => id.do_stuff(),
    PropertyKey::PrivateIdentifier(id) = id.do_stuff(),
    match_expression!(PropertyKey) => prop_key.to_expression().do_stuff(),
}

Would this be better?

match_with_subtypes!(prop_key, {
    PropertyKey::StaticIdentifier(id) => id.do_stuff(),
    PropertyKey::PrivateIdentifier(id) = id.do_stuff(),
    @subtype::PropertyKey::Expression(expr) => expr.do_stuff(),
});

This reduces boilerplate and makes the code easier to read. But is it too much magic?

@rzvxa You had strong opinions on this matter. Would you like to chime in?

[overlookmotel]

The above match_with_subtypes! example would expand to:

match prop_key {
    PropertyKey::StaticIdentifier(id) => id.do_stuff(),
    PropertyKey::PrivateIdentifier(id) = id.do_stuff(),
    expr @ (
        PropertyKey::BooleanLiteral(_)
        | PropertyKey::NullLiteral(_)
        /* ...and all the other Expression variants */
    ) => {
        let expr = expr.to_expression();
        expr.do_stuff()
    }
}

[rzvxa]

@rzvxa You had strong opinions on this matter. Would you like to chime in?

I've mulled it over for a couple of days, I still believe it adds to the code noise and makes stuff harder to follow. But if we are committing to this, Let's do it all the way!

[overlookmotel]

@hyf0 suggested an alternative on Discord:

Extend existing match_* macros to allow this:

match expr {
    match_member_expression!(member_expr @ Expression) => member_expr.do_stuff()
}

which would expand to:

match expr {
    _temp @ (
        Expression::ComputedMemberExpression(_)
        | Expression::StaticMemberExpression(_)
        | Expression::PrivateFieldExpression(_)
    ) => {
        let member_expr = _temp.to_member_expression();
        member_expr.do_stuff()
    }
}

I think this is really good! @rzvxa you like?

[rzvxa]

Yes, I like what I'm seeing. I'm glad we gave this issue a bit of time because it seems like a more natural way of expressing the same thing we wanted in the original comment.

Small nit, Shouldn't we expand to this?

match expr {
    member_expr @ (
        Expression::ComputedMemberExpression(_)
        | Expression::StaticMemberExpression(_)
        | Expression::PrivateFieldExpression(_)
    ) => {
        let member_expr = member_expr.to_member_expression();
        member_expr.do_stuff()
    }
}

[overlookmotel]

Small nit, Shouldn't we expand to this?

Yes, you're right. That's better.

[overlookmotel]

Argh I forgot I tried this before, and it doesn't work! It'd have to be:

match expr {
    match_member_expression!( member_expr @ Expression => member_expr.do_stuff() )
}

And macros do not support expanding to match arms.

[rzvxa]

I was about to point out the match arms issue😅