Extract own IR inside IRTools dynamo - compilation

Question

I'm trying to write an IRTools dynamo which will internally use the IR of the method it is called on. As a simplified example, keep_ir(f, args...) should return (f(args...), IR(f, args...)).
I tried the following:
IRTools.#dynamo function keep_ir(f, args...)
old_ir = IRTools.IR(f, args...)
new_ir = IRTools.empty(old_ir)
foreach(arg -> IRTools.argument!(new_ir), IRTools.arguments(old_ir))
foreach(((v, stmt),) -> push!(new_ir, stmt.expr), old_ir)
arg_types = [IRTools.xcall(Core, :Typeof, arg) for arg in IRTools.arguments(old_ir)]
original_ir = push!(new_ir, IRTools.xcall(IRTools, :IR,
IRTools.xcall(IRTools, :meta,
IRTools.xcall(Core, :apply_type,
:(Base.Tuple),
arg_types...))))
old_rv = IRTools.branches(IRTools.block(old_ir, 1))[end]
new_rv = push!(new_ir, IRTools.xcall(:tuple, old_rv.args[1], original_ir))
IRTools.return!(new_ir, new_rv)
#show new_ir # for debugging
return new_ir
end
but it fails with an obcure error:
julia> ff(x, y) = 4x + y^2, x
ff (generic function with 1 method)
julia> keep_ir(ff, 1, 20)
new_ir = 1: (%1, %2, %3)
%4 = 4 * %2
%5 = Core.apply_type(Base.Val, 2)
%6 = (%5)()
%7 = Base.literal_pow(Main.:^, %3, %6)
%8 = %4 + %7
%9 = Core.tuple(%8, %2)
%10 = Base.Tuple
%11 = Core.Typeof(%1)
%12 = Core.Typeof(%2)
%13 = Core.Typeof(%3)
%14 = Core.apply_type(%10, %11, %12, %13)
%15 = IRTools.meta(%14)
%16 = IRTools.IR(%15)
%17 = Base.tuple(%9, %16)
return %17
ERROR: error compiling keep_ir: unsupported or misplaced expression "." in function keep_ir
Stacktrace:
[1] top-level scope at REPL[76]:1
caused by [exception 1]
unsupported or misplaced expression "." in function keep_ir
Stacktrace:
[1] top-level scope at REPL[76]:1
The IR it constructed looks good to me, though...

Answer 1

Rather than trying to reconstruct the IR at run time, you can just splice it in as a value at compile time:
using IRTools
using IRTools: #dynamo, IR, returnvalue, block, xcall, return!
#dynamo function keepir(args...)
ir = IR(args...)
ir2 = copy(ir)
ret = push!(ir, xcall(:tuple, returnvalue(block(ir, 1)), ir2))
return!(ir, ret)
return ir
end
ff(x, y) = 4x + y^2, x
keepir(ff, 2, 3) # => ((17, 2), IR(...))
FWIW, the error you see is probably coming from the expression :(Base.Tuple) that you put in the IR. It should work if you use GlobalRef(Base, :Tuple) instead.