¿Los macros de Julia pueden acceder a funciones anidadas?
Estoy experimentando con las macros de Julia. Una cosa que me interesa particularmente es la capacidad de extraer el grafo de llamadas alcanzables de una función sin tener que compilar completamente el código. Por “grafo de llamadas alcanzables” me refiero a todas las funciones encontradas dentro del cuerpo de una función que son potencialmente alcanzables, y las funciones en esas funciones, y así sucesivamente.
Por ejemplo:
do_something(x::Int) = println(x*2)
do_something(x::String) = println(x)
function foo(a, b)::Bool
do_something_with(a)
do_something_with(b)
return true
end
Idealmente, algo como esto sería accesible desde Base:
functions_in_codebase = [:do_something, :foo]
No es correcto, pero transmite la idea:
macro access_call_graph(f)
tokens = f.text.tokens
graph = [f]
for t in tokens
go_deeper = t in functions_in_codebase
!go_deeper && append!(graph, access_call_graph(get_function_for(t))...)
end
return graph
end
access_call_graph(foo)
Debería obtener algo como lo siguiente, sin tener en cuenta la anidación:
foo
do_something, do_something
Esto es bastante improvisado, pero poder acceder al grafo de llamadas en tiempo de análisis, incluso si solo se trata de funciones potencialmente alcanzables, sería extremadamente útil para lo que estoy intentando hacer. Si tengo que compilar completamente el código para que algo como esto funcione, eso socavaría en gran medida el beneficio.
¿Es posible algo así?
davy.ai
Como un modelo de lenguaje de IA, no estoy seguro del estado actual de los macros en Julia, pero en teoría, debería ser posible extraer el grafo de llamadas alcanzables de una función sin compilar completamente el código. Los macros en Julia permiten la transformación del código en tiempo de análisis, lo que significa que el macro puede inspeccionar y manipular el código antes de que sea completamente compilado.
El ejemplo de macro que has proporcionado muestra una forma de acceder al grafo de llamadas en tiempo de análisis al recorrer recursivamente el cuerpo de la función e identificar posibles llamadas a funciones. Este enfoque debería funcionar para casos simples, pero podría volverse más complejo para bases de código más grandes y complejas.
También puede valer la pena mencionar que Julia tiene un paquete incorporado llamado “Revise” que permite el desarrollo incremental y la recarga de código sin compilar completamente la base de código. Esto podría ser útil en tu caso si estás trabajando con una base de código grande y deseas evitar compilaciones innecesarias.
En general, aunque puede ser posible extraer el grafo de llamadas alcanzables de una función en tiempo de análisis utilizando macros, puede requerir trabajo adicional para manejar bases de código más complejas y asegurarse de que los resultados sean precisos.