Abstract enums created by macros not behaving correctly

[bendmorris]

(Currently using Haxe 3.1.3)

I'm trying to create an abstract enum with values defined in a macro, and am getting some strange behavior.

Here's a simple example of a regular abstract enum:

@:enum
abstract MyEnum(String) from String to String
{
    var A = 'a';
    var B = 'b';
    var C = 'c';
}

class MyClass
{
    static function myFunc(arg:MyEnum):String
    {
        switch(arg)
        {
            case A: return "GOT AN A";
            case B: return "GOT A B";
            default: return ""+arg;
        }
    }
}

I can compile this and it works correctly; if I leave out the "default" case, I get an error for the missing pattern.

Now I try to replicate this using a macro:

import haxe.macro.Context;
import haxe.macro.Expr;

class TestMacro
{
    macro static public function build():Array<Field>
    {
        var fields = Context.getBuildFields();
        var macroFields = ['a', 'b', 'c'];
        for (f in macroFields)
        {
            fields.push({
                name: f.toUpperCase(),
                doc: null,
                meta: [],
                access: [AStatic, APublic],
                kind: FVar(macro : String, macro $v{f}),
                pos: Context.currentPos(),
            });
        }
        return fields;
    }
}

#if !macro @:build(TestMacro.build()) #end
@:enum
abstract MyEnum(String) from String to String
{
}

#if !macro
class MyClass
{
    static function myFunc(arg:MyEnum):String
    {
        switch(arg)
        {
            case A: return "GOT AN A";
            case B: return "GOT A B";
            default: return ""+arg;
        }
    }
}
#end

I can use MyEnum.A, MyEnum.B, and MyEnum.C with no problem. However, I generate PHP code from this and notice:

• there's no warning from the compiler when missing cases in the switch

• also, more seriously: the default case from the switch doesn't show up in the generated PHP!

  <?php
  
  class MyClass {
      public function __construct(){}
      static function myFunc($arg) {
          switch($arg) {
          case "a":{
              return "GOT AN A";
          }break;
          case "b":{
              return "GOT A B";
          }break;
          }
      }
      function __toString() { return 'MyClass'; }
  }
  

So if I have an enum of 20 values and a switch with two cases followed by a default case, the PHP switch will only check for two of those values, and with no default, will return "null" for everything else.

Is this a bug, or am I not constructing the enum correctly? Is what I want to do possible?

[nadako]

for some weird reason, @:build macros is run on the impl class and not the abstract. because of that, you need to add @:impl and @:enum metadata to your enum case fields. hope that'll help

[bendmorris]

You're right, added:

meta: [{pos:Context.currentPos(), name:":impl"},{pos:Context.currentPos(), name:":enum"}],

and everything looks good now. Thanks for your help @nadako!

[ncannasse]

It seems weird indeed, we might want to fix this :)

[nadako]

That would be a breaking change...

[ncannasse]

Since then are we having abstract build macros ?

[nadako]

I don't know. Since the beginning? :)

[Simn]

The whole point is that it's not really abstract build macros, but just normal build macros on the abstract implementation class. The implementation for this came "for free" with the downside of having to manually deal with the transformation the typer usually does.

I agree it's not perfect, but I'm reluctant to change it at this point.

[nadako]

I think we could change that for 3.3. It is a breaking change, but i think most users would be glad to clean their macro code of these transformations. We could even provide some "migration guide", but I think people who are capable of writing a build-macro for an abstract implementation class will have no problem adapting it for abstract build macro.

[Simn]

Fine with me, but I suspect this will be a non-trivial change.

[boozook]

It would be really cool.