Macro to fill out field names, values, and switch statements of a custom #:enum abstract? - macros

Question

I have a bit of a unique situation. For various reasons, chiefly interoperating with a nullable stringly typed legacy system, as well as various other needs I won't go into at the moment, I've settled on a custom #:enum abstract that looks like this:
#:enum abstract MyEnum(Null<Int>) {
public var A = 0;
public var B = 1;
public var C = 2;
public var D = 3;
public var E = 4;
public var F = 5;
public var G = 6;
#:from private static function fromString (value:String):MyEnum {
return switch (value) {
case "a": A;
case "b": B;
case "c": C;
case "d": D;
case "e": E;
case "f": F;
case "g": G;
default: null;
}
}
#:to private static function toString (value:Int):String {
return switch (value) {
case A: "a";
case B: "b";
case C: "c";
case D: "d";
case E: "e";
case F: "f";
case G: "g";
default: null;
}
}
}
However, that's an annoyingly large amount of things to type, and when adding and removing members it's easy to make a manual error. Clearly, this follows a super predictable pattern and seems like a great thing to construct with a macro, but I am terrible at haxe macros.
Can someone explain how I could use a macro to build this enum in such a way that all I have to supply is a list of field names?
pseudocode:
#:enum abstract MyEnum = doTheMacroMagic(["A","B","C","D","E","F","G"]);
The logical steps would be:
Declare public vars from field names (upper case)
Declare fromString/toString values from field names (lower case)
Set public vars to 0-based integers and follow same order as field names are supplied
I think a simple practical example like this might make haxe macros finally "click" for me if I can see it in action.

Answer 1

Flixel handles a very similar use case in for classes like FlxKey with FlxMacroUtil.buildMap(). This expression macro looks for all uppercase, inline vars it finds in the abstract and generates a Map<String, EnumType> from it, with the keys being the field names and the values the field values (or the inverse of that if invert is true).
#:enum
abstract FlxKey(Int) from Int to Int
{
public static var fromStringMap(default, null):Map<String, FlxKey>
= FlxMacroUtil.buildMap("flixel.input.keyboard.FlxKey");
public static var toStringMap(default, null):Map<FlxKey, String>
= FlxMacroUtil.buildMap("flixel.input.keyboard.FlxKey", true);
var A = 65;
var B = 66;
// more keys...
#:from
public static inline function fromString(s:String)
{
s = s.toUpperCase();
return fromStringMap.exists(s) ? fromStringMap.get(s) : NONE;
}
#:to
public inline function toString():String
{
return toStringMap.get(this);
}
}
I'd imagine that's a good starting point. If you want to generate the entire abstract, you will need a #:build macro.
Answering the follow-up question, how to generate fields: This is actually quite straightforward with a build macro:
#:enum
#:build(Macro.createVariables(["A", "B", "C", "D", "E"]))
abstract Generated(Int)
{
}
Macro.hx (sensible to have in its own file to avoid having to deal with #if macro conditionals):
package;
import haxe.macro.Context;
import haxe.macro.Expr;
class Macro
{
public static macro function createVariables(varNames:Array<String>):Array<Field>
{
// get the current fields of the calling type (empty array in this case)
var fields = Context.getBuildFields();
for (i in 0...varNames.length)
// create a custom variable and add it to the fields
fields.push(createVariable(varNames[i], i));
return fields;
}
private static function createVariable(name:String, value:Int):Field
{
return {
name: name,
doc: null,
meta: [],
access: [Access.APublic, Access.AStatic, Access.AInline],
kind: FieldType.FVar(macro:Int, macro $v{value}),
pos: Context.currentPos()
}
}
}
You'll notice the fields showing up in auto-completion for Generated.. You can also see what's been generated by looking at the Generated_Impl.dump when doing an AST dump.