@:using not working as intended when handling Class<> and Enum<>

[ZwodahS]

Considering the following code

class EnExtension {
    public static function toS(e: En): String {
        return '${e}';
    }
    public static function fromS(en: Enum<En>, st: String): En {
        return A;
    }
}
@:using(Test.EnExtension)
enum En {
    A;
    B;
}
class Test {
  static public function main() {
      var e: En = A;
      trace(e.toS());
      var f: En = En.fromS("A"); // Error ?
  }
}

The similar thing also happen with Class<>

class CExtension {
    public static function toS(c: C): String {
        return 'c';
    }
    public static function fromS(cls: Class<C>, s: String) {
        return new C();
    }
}

@:using(Test.CExtension)
class C {
    public function new(){}
}


class Test {
  static public function main() {
      var c = new C();
      trace(c.toS());
      var d = C.fromS('c'); // Error ?
      trace(d);
  }
}

This don't seems to be a problem with static extensions but rather a problem with @:using. By explicitly defining using Test.CExtensions and using Test.EnExtensions, the code will run just fine.

Couldn't find an existing issues regarding this, if there is one, kindly just close the issue.

[Aurel300]

The issue is that @:using adds the static extensions to instances of the annotated type. That is:

@:using(FooTools)
enum Foo {}

Here Foo gets statically extended with methods from FooTools that have the signature (Foo, ...) -> ..., taking an instance of Foo as the first argument. There is no equivalent of a type-level @:using in Haxe.

What is the intended usage of this? Is this for de/serialisation?

[ZwodahS]

Not really just for de/serialization.

Knowing that @:using only add the extensions to instances of the type, I understand why this doesn't work.
I guess I will just put the using statement in my import.hx.

[Simn]

I don't really see a reason why this shouldn't work. The usage of Class<T> and Enum<T> clearly suggests the intent here, so I think we can look into supporting this.