tools.analyzer AST Quickref

Common AST fields

:op
The node op
:form
The clojure form from which the node originated
:env
The environment map
:children
optional A vector of keywords, representing the children nodes of this node, in order of evaluation
:raw-forms
optional If this node's :form has been macroexpanded, a sequence of all the intermediate forms from the original form to the macroexpanded form
:top-level
optional true if this is the root node

Nodes reference

#binding

Node for a binding symbol

:op
:binding
:form
The binding symbol
:name
The binding symbol
:local
One of :arg, :catch, :fn, :let, :letfn or :loop
:arg-id
optional When :local is :arg, the parameter index
:variadic?
optional When :local is :arg, a boolean indicating whether this parameter binds to a variable number of arguments
:init
optional When :local is :let, :letfn or :loop, an AST node representing the bound value
:children
[], [:init]

#catch

Node for a catch expression

:op
:catch
:form
(catch class local body*)
:class
A :maybe-class AST node representing the type of exception to catch
:local
The :binding AST node for the caught exception
:body
Synthetic :do AST node (with :body? true) representing the body of the catch clause
:children
[:class :local :body]

#const

Node for a constant literal or a quoted collection literal

:op
:const
:form
A constant literal or a quoted collection literal
:literal?
true
:type
one of :nil, :bool, :keyword, :symbol, :string, :number, :type, :record, :map, :vector, :set, :seq, :char, :regex, :class, :var, or :unknown
:val
The value of the constant node
:meta
optional An AST node representing the metadata of the constant value, if present. The node will be either a :map node or a :const node with :type :map
:children
[], [:meta]

#def

Node for a def special-form expression

:op
:def
:form
(def name docstring? init?)
:name
The var symbol to define in the current namespace
:var
The var object created (or found, if it already existed) named by the symbol :name in the current namespace
:meta
optional An AST node representing the metadata attached to :name, if present. The node will be either a :map node or a :const node with :type :map
:init
optional An AST node representing the initial value of the var
:doc
optional The docstring for this var
:children
[], [:init], [:meta], [:meta :init]

#do

Node for a do special-form expression or for another special-form's body

:op
:do
:form
(do statement* ret)
:statements
A vector of AST nodes representing all but the last expression in the do body
:ret
An AST node representing the last expression in the do body (the block's return value)
:body?
optional true if this node is a synthetic body
:children
[:statements :ret]

#fn

Node for a fn* special-form expression

:op
:fn
:form
(fn* name? [arg*] body*) or (fn* name? method*)
:variadic?
true if this function contains a variadic arity method
:max-fixed-arity
The number of arguments taken by the fixed-arity method taking the most arguments
:local
optional A :binding AST node with :local :fn representing the function's local name, if one is supplied
:methods
A vector of :fn-method AST nodes representing the fn method arities
:once
true if the fn is marked as ^:once fn*, meaning it will only be executed once and thus allowing for the clearing of closed-over locals
:children
[:methods], [:local :methods]

#fn-method

Node for an arity method in a fn* expression

:op
:fn-method
:form
([arg*] body*)
:loop-id
Unique symbol identifying this method as a target for recursion
:variadic?
true if this fn-method takes a variable number of arguments
:params
A vector of :binding AST nodes with :local :arg representing this fn-method args
:fixed-arity
The number of non-variadic args this fn-method takes
:body
Synthetic :do node (with :body? true) representing the body of this fn-method
:children
[:params :body]

#host-call

Node for a host interop call

:op
:host-call
:form
(.method target arg*)
:method
Symbol naming the method to call
:target
An AST node representing the target object
:args
A vector of AST nodes representing the args passed to the method call
:children
[:target :args]

#host-field

Node for a host interop field access

:op
:host-field
:form
(.-field target)
:field
Symbol naming the field to access
:target
An AST node representing the target object
:assignable?
true
:children
[:target]

#host-interop

Node for a no-arg host interop call or for a host interop field access

:op
:host-interop
:form
(. target m-or-f)
:target
An AST node representing the target object
:m-or-f
Symbol naming the no-arg method or field to access in the target
:assignable?
true
:children
[:target]

#if

Node for an if special-form expression

:op
:if
:form
(if test then else?)
:test
An AST node representing the test expression
:then
An AST node representing the expression's return value if :test evaluated to a truthy value
:else
An AST node representing the expression's return value if :test evaluated to a falsey value, if not supplied it will default to a :const node representing nil
:children
[:test :then :else]

#invoke

Node for an invoke expression

:op
:invoke
:form
(f arg*)
:fn
An AST node representing the function to invoke
:args
A vector of AST nodes representing the args to the function
:meta
optional Map of metadata attached to the invoke :form
:children
[:fn :args]

#let

Node for a let* special-form expression

:op
:let
:form
(let* [binding*] body*)
:bindings
A vector of :binding AST nodes with :local :let
:body
Synthetic :do node (with :body? true) representing the body of the let expression
:children
[:bindings :body]

#letfn

Node for a letfn* special-form expression

:op
:letfn
:form
(letfn* [binding*] body*)
:bindings
A vector of :binding AST nodes with :local :letfn
:body
Synthetic :do node (with :body? true) representing the body of the letfn expression
:children
[:bindings :body]

#local

Node for a local symbol

:op
:local
:form
The local symbol
:name
The local symbol
:local
One of :arg, :catch, :fn, :let, :letfn or :loop
:arg-id
optional When :local is :arg, the parameter index
:assignable?
true if the local is mutable
:variadic?
optional When :local is :arg, a boolean indicating whether this parameter binds to a variable number of arguments

#loop

Node a loop* special-form expression

:op
:loop
:form
(loop* [binding*] body*)
:bindings
A vector of :binding AST nodes with :local :loop
:body
Synthetic :do node (with :body? true) representing the body of the loop expression
:loop-id
Unique symbol identifying this loop as a target for recursion
:children
[:bindings :body]

#map

Node for a map literal

:op
:map
:form
{[key val]*}
:keys
A vector of AST nodes representing the keys of the map
:vals
A vector of AST nodes representing the vals of the map
:children
[:keys :vals]

#maybe-class

Node for a not-namespaced symbol that couldn't be resolved as a var

:op
:maybe-class
:form
The not namespaced symbol
:class
The not namespaced symbol that might represent a class

#maybe-host-form

Node for namespaced symbol that couldn't be resolved as a var

:op
:maybe-host-form
:form
The namespaced symbol
:class
The namespace part of the symbol, as a symbol
:field
The name part of the symbol, as a symbol

#new

Node for a new special-form expression

:op
:new
:form
(new Class arg*)
:class
A :maybe-class AST node :class representing the Class to instantiate
:args
A vector of AST nodes representing the arguments passed to the Class constructor
:children
[:class :args]

#quote

Node for a quote special-form expression

:op
:quote
:form
(quote expr)
:expr
A :const AST node representing the quoted value
:literal?
true
:children
[:expr]

#recur

Node for a recur special-form expression

:op
:recur
:form
(recur expr*)
:exprs
A vector of AST nodes representing the new bound values for the loop binding on the next loop iteration
:loop-id
Unique symbol identifying the enclosing loop target
:children
[:exprs]

#set

Node for a set literal

:op
:set
:form
#{item*}
:items
A vector of AST nodes representing the items of the set
:children
[:items]

#set!

Node for a set! special-form expression

:op
:set!
:form
(set! target val)
:target
An AST node representing the target of the set! expression, must be :assignable?
:val
An AST node representing the new value for the target
:children
[:target :val]

#throw

Node for a throw special-form statement

:op
:throw
:form
(throw exception)
:exception
An AST node representing the exception to throw
:children
[:exception]

#try

Node for a try special-form expression

:op
:try
:form
(try body* catch* finally?)
:body
Synthetic :do AST node (with :body? true) representing the body of this try expression
:catches
A vector of :catch AST nodes representing the catch clauses of this try expression
:finally
optional Synthetic :do AST node (with :body? true) representing the final clause of this try expression
:children
[:body :catches], [:body :catches :finally]

#var

Node for a var symbol

:op
:var
:form
A symbol naming the var
:var
The var object this symbol refers to
:assignable?
optional true if the Var is :dynamic

#vector

Node for a vector literal with attached metadata and/or non literal elements

:op
:vector
:form
[item*]
:items
A vector of AST nodes representing the items of the vector
:children
[:items]

#with-meta

Node for a non quoted collection literal or a fn expression with attached metadata

:op
:with-meta
:form
Non quoted collection literal or fn expression with attached metadata
:meta
An AST node representing the metadata of expression. The node will be either a :map node or a :const node with :type :map
:expr
The expression this metadata is attached to, :op is one of :vector, :map, :set or :fn
:children
[:meta :expr]