Passing code to macro

[ncannasse]

I often want to have a macro which can be user-customized. Currently we can pass constants to the macros but we cannot pass a class or a static method.

I give it a try today but it seems a bit hard to do. Another option is to use Reflection by allowing macro code to dynamically add new classes to its context.

[frabbit]

i thought about macro configuration and i came up with this idea

https://gist.github.com/frabbit/8698596

in short it's a little bit like partial application for macros or macros returning new macros based on input.

but i really don't know if that has anything todo with what you meant ;).

[frabbit]

i have also the problem that i want to pass a function to a macro via commandline like this:

--macro MyMacro(function (x) return "foo")
or
--macro MyMacro(MyConfig.foo)

this feature would make it a lot easier to write reusable configuration macros. I also had the case that i wanted to use Compiler.include with a flexible function as filter instead of a string.

[ncannasse]

Already tried a few times but it's actually quite a complex problem to solve

[Simn]

I wanted to understand this better so I did what I usually do and went for an implementation:

Simn@a885c2e

My idea was to introduce a new builtin $toValue which transforms its argument like so:

[neko AST]
decode_expr
[Haxe AST]
type_expr
[Haxe typed AST]
Genneko.gen_expr
[neko AST]

This can then be evaluated in the interpreter and was already enough to pass in function expressions and invoke them in a macro like this:

class Macro {
    macro static public function call(efun:ExprOf<Int->Int>, eval:Expr):Expr {
        var vfun = untyped $toValue(efun);
        var vval = untyped $toValue(eval);
        var r = vfun(vval);
        return macro $v{r};
    }
}

Passing in references to static function didn't work yet because they were not part of the macro context by default. For that I iterated the decoded typed AST to find all TField(_, FStatic) and then used load_macro on these.

Is what I'm doing here at all related to the general idea?

[ncannasse]

@Simn that's a first step, but this looks more like some way to dynamically load/link code.
Ideally we would like to be able to do:

macro function foo( v : Void -> Void ) {
}
// ...

foo(MyClass.method}

But then we start having error reporting issues when MyClass is not compilable in macro context, etc.

So I guess your solution is the best we can have.

Should we move it into Context instead of a primitive ? Context.eval(Expr):Dynamic or is there an implementation issue with it ?

[Simn]

Oh, hmm, for some reason I didn't even consider adding it to Context. I don't see a problem with that though and it's definitely a nicer API.

[Simn]

It might be possible to allow your foo case later if we detect it and turn the macro into this:

macro function foo(v:Expr) {
    var v:Void -> Void = Context.eval(v);
}

[ncannasse]

Yes, but there are restrictions with it no ? (like only FStatic ?)

[Simn]

FStatic and direct function expressions. I'm not sure what else would be useful because all other cases carry some context which doesn't make much sense in the macro context.

[Simn]

I've added Context.eval and also got the direct calls working. Not entirely sure about the latter because type_macro is a bit of an assumption hell.