add @locals macro for obtaining dictionary of local vars and values

[JeffBezanson]

implements #29366

[StefanKarpinski]

Wouldn't it make more sense for this to return a named tuple?

[JeffBezanson]

I see this as just a reflection and debugging kind of thing, so a somewhat loosely-typed dictionary seems appropriate. The order of the variables is also going to be all over the place, so not having a well-defined order is a feature.

[dalum]

Could this be useful in code generation as well? Something like:

function eval_with_local_vars(expr::Expr, x, y)
    @eval let $(dict_as_assignments(@locals))
        $expr
    end
end

which would now let expr contain the symbols x and y, for a suitable definition of dict_as_assignments.

[yuyichao]

Could this be useful in code generation as well?

No.

[StefanKarpinski]

Could this be useful in code generation as well?

No.

To expand on this a bit, in your example, the @eval is evaluated in global scope, so injecting local names doesn't have the effect you'd want. If you move the @eval outside of the function body then the eval has the effect you want but @locals is being called from a global context, not from the function body. So this is pretty much only useful for exposing what's in a local scope.

[dalum]

I just checked out the branch and it actually does have the effect that I want, so maybe I didn't describe it properly. 😊 The point is that the thing inside the function body of f here easily translates into a macro that will work in all local scopes, without requiring the user to manually specify the dict of local variables. The example below is, of course, just a silly example:

julia> function f(expr, x, y)
           __locals__ = Base.@locals()
           ex = Expr(:let, Expr(:block), Expr(:block,
               :(__locals__ = $__locals__),
               (:($key = __locals__[$(QuoteNode(key))]) for (key) in keys(__locals__))...,
               :(__return__ = $expr),
               (:(__locals__[$(QuoteNode(key))] = $key) for (key) in keys(__locals__))...,
               :(__return__)))
           return eval(ex)
       end
f (generic function with 1 method)

julia> expr = :((a) -> a + x + y);

julia> h = f(expr, 1, 2)
#199 (generic function with 1 method)

julia> h(3)
6

If it was possible to write back to the @locals dict to modify the local scope, that would be really cool, though ...

[StefanKarpinski]

If it was possible to write back to the @locals dict to modify the local scope

This may sound good but it ruins all ability to optimize anything.