Question

我想使用宏来获取Haxe函数的参数类型，并将它们转换为简写字符串形式，有点像JNI / Java方法签名，但没有返回类型。

这里的动机是提供对函数参数类型的访问，而不必在运行时慢慢搜索运行时类型信息。例如，假设您要构建一个图形小部件来调用带参数的函数。您将需要每个函数参数的类型来创建正确的旋转框，文本框和选择框小部件，以便调整将传递给函数的值。

所以问题是，如何用宏保存Haxe函数参数类型？

Answer 1

这是一个适用于几种基本类型的宏，以及基于这些类型的任何摘要。它将函数参数类型映射到字符串。例如，函数类型String->Float->Int->String->Void映射到sfis，Float->Float->Int映射到ff等：

package;

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

// Map some Haxe types to string ids
@:enum abstract TypeMapping(String) from (String) {
    var BOOL = "b";
    var FLOAT = "f";
    var INT = "i";
    var STRING = "s";
}

class Util
{
    public macro static function getParameterTypes(f:Expr):ExprOf<String> {
        var type:Type = Context.typeof(f);
        if (!Reflect.hasField(type, 'args')) {
            throw "Parameter has no field 'args'";
        }
        var t = type.getParameters()[0];

        var args:Array<Dynamic> = Reflect.field(type, 'args')[0];

        var signature:String = "";
        for (i in 0...args.length) {            
            switch(args[i].t) {
                case TAbstract(t, p):
                    var underlyingTypeName = Std.string(t.get().type.getParameters()[0]);
                    switch(underlyingTypeName) {
                        case "Bool":
                            signature += TypeMapping.BOOL;
                        case "Float":
                            signature += TypeMapping.FLOAT;
                        case "Int":
                            signature += TypeMapping.INT;
                        case "String":
                            signature += TypeMapping.STRING;
                        default:
                            throw "Unhandled abstract function parameter type: " + underlyingTypeName;
                    }
                case CString:
                    signature += TypeMapping.STRING;
                default:
                    throw "Unhandled function parameter type: " + args[i];
            }
        }
        return macro $v{signature};
    }
}

另一个问题是如何使所有类型工作，而不仅仅是你明确处理的类型。为此，您可以使用每个函数参数的类型名称/类名称/路径填充字符串数组，并返回该字符串而不是单个字符串。这是一次尝试，注意它还没有使用函数参数（可能还有其他东西）：

public macro static function getFullParameterTypes(f:Expr):ExprOf<Array<String>> {
    var type:Type = Context.typeof(f);
    if (!Reflect.hasField(type, 'args')) {
        throw "Parameter has no field 'args'";
    }
    var args:Array<Dynamic> = Reflect.field(type, 'args')[0];

    var pos = haxe.macro.Context.currentPos();
    var signature:Array<Expr> = [];

    for (i in 0...args.length) {
        var argType:Type = args[i].t;
        var s;
        switch(argType) {
            case TFun(t, r):
                s = EConst(CString("Function"));
                throw "Not working with function parameters yet";
            case _:
                s = EConst(CString(argType.getParameters()[0].toString()));
        }
        signature.push({expr: s, pos: pos});
    }
    return macro $a{signature};
}

使用宏获取Haxe函数参数类型的最佳方法是什么？

1 个答案: