Generic macro abstract function!

GenericBuildMacro.hx

import haxe.macro.TypeTools;
import haxe.macro.Expr;
import haxe.macro.Context;
import haxe.macro.Type;

class GenericBuildMacro {

    static public function build():ComplexType {

        var pos = Context.currentPos();

        var fields = new Array<Field>();

        switch (Context.getLocalType()) {
            case TInst(_,[TInst(_.get() => { kind: KExpr(_.expr=>EArrayDecl(a)) },_)]):
                fields.push({
                    name: 'new',
                    kind: FFun({
                        args: [{
                            name: 'fn',
                            type: TFunction(
                                a.map(e -> switch e.expr {
                                    case EConst(CIdent(c)):
                                        TypeTools.toComplexType(Context.getType(c));
                                    case _: throw  'error';
                                }),
                                macro:Void
                            ),
                        }],
                        ret: null,
                        expr: macro this = fn
                    }),
                    pos: pos,
                    access: [APublic]
                });
                var n:Int = 0;
                fields.push({
                    name: 'call',
                    kind: FFun({
                        args: a.map(e -> switch e.expr {
                                case EConst(CIdent(c)): {
                                    name: 'arg${n++}',
                                    type: TypeTools.toComplexType(Context.getType(c)),
                                    opt: false,
                                    value: null,
                                    meta: null
                                }
                                case _: throw  'error';
                            }),
                        ret: null,
                        expr: {expr: ECall(macro this, [for (v in 0...n) macro $i{'arg$v'}]), pos: pos}
                    }),
                    pos: pos,
                    access: [APublic]
                });

            case t:
            Context.error("Class expected", Context.currentPos());
        }

        var classPath = {pack : ['gen'], name:"AbstractFn"}
        var typeDefinition : TypeDefinition = {
            pos : pos,
            pack : classPath.pack,
            name : classPath.name,
            kind :TDAbstract(macro :haxe.Constraints.Function),
            fields: fields
        }

        Context.defineType(typeDefinition);

        return TPath(classPath);
    }

}

Main.hx

class Main {

	private static function main():Void {
		var c:String = '';
		var x = new Fn<[String, Int]>((a, b) -> c = a + b);
		x.call('a', 3);
		trace(c);
		x.call('c', 8);
		trace(c);
	}

}

@:genericBuild(GenericBuildMacro.build())
class Fn<Const> {}