clojure.tools.analyzer — org.clojure/tools.analyzer 1.0.0

Analyzer for clojure code, host agnostic.

Entry point:

• analyze

Platform implementers must provide dynamic bindings for:

• macroexpand-1
• parse
• create-var
• var?

Setting up the global env is also required, see clojure.tools.analyzer.env

See clojure.tools.analyzer.core-test for an example on how to setup the analyzer.

-analyze-form clj multimethod

-parse clj

(-parse form env)

Takes a form and an env map and dispatches on the head of the form, that is a special form.

analyze clj

(analyze form env)

Given a form to analyze and an environment, a map containing:

• :locals a map from binding symbol to AST of the binding value
• :context a keyword describing the form's context from the :ctx/* hierarchy. ** :ctx/expr the form is an expression: its value is used ** :ctx/return the form is an expression in return position, derives :ctx/expr ** :ctx/statement the value of the form is not used
• :ns a symbol representing the current namespace of the form to be analyzed

returns an AST for that form.

Every node in the AST is a map that is guaranteed to have the following keys:

• :op a keyword describing the AST node
• :form the form represented by the AST node
• :env the environment map of the AST node

Additionaly if the AST node contains sub-nodes, it is guaranteed to have:

• :children a vector of the keys of the AST node mapping to the sub-nodes, ordered, when that makes sense

It is considered a node either the top-level node (marked with :top-level true) or a node that can be reached via :children; if a node contains a node-like map that is not reachable by :children, there's no guarantee that such a map will contain the guaranteed keys.

analyze-body clj

(analyze-body body env)

analyze-const clj

(analyze-const form env & [type])

analyze-fn-method clj

(analyze-fn-method [params & body :as form] {:keys [locals local] :as env})

analyze-form clj multimethod

Like analyze, but does not mark the form with :top-level true

analyze-in-env clj

(analyze-in-env env)

Takes an env map and returns a function that analyzes a form in that env

analyze-let clj

(analyze-let [op bindings & body :as form] {:keys [context loop-id] :as env})

analyze-map clj

(analyze-map form env)

analyze-seq clj

(analyze-seq form env)

analyze-set clj

(analyze-set form env)

analyze-symbol clj

(analyze-symbol sym env)

analyze-vector clj

(analyze-vector form env)

create-var clj

(create-var sym env)

Creates a var for sym and returns it

empty-env clj

(empty-env)

Returns an empty env

macroexpand clj

(macroexpand form env)

Repeatedly calls macroexpand-1 on form until it no longer represents a macro form, then returns it.

macroexpand-1 clj

(macroexpand-1 form env)

If form represents a macro form, returns its expansion, else returns form.

parse clj

(parse [op & args] env)

Multimethod that dispatches on op, should default to -parse

parse-catch clj

(parse-catch [_ etype ename & body :as form] env)

parse-def clj

(parse-def [_ sym & expr :as form] {:keys [ns] :as env})

parse-do clj

(parse-do [_ & exprs :as form] env)

parse-dot clj

(parse-dot [_ target & [m-or-f & args] :as form] env)

parse-fn* clj

(parse-fn* [op & args :as form] env)

parse-if clj

(parse-if [_ test then else :as form] env)

parse-invoke clj

(parse-invoke [f & args :as form] env)

parse-let* clj

(parse-let* form env)

parse-letfn* clj

(parse-letfn* [_ bindings & body :as form] env)

parse-loop* clj

(parse-loop* form env)

parse-new clj

(parse-new [_ class & args :as form] env)

parse-quote clj

(parse-quote [_ expr :as form] env)

parse-recur clj

(parse-recur [_ & exprs :as form] {:keys [context loop-locals loop-id] :as env})

parse-set! clj

(parse-set! [_ target val :as form] env)

parse-throw clj

(parse-throw [_ throw :as form] env)

parse-try clj

(parse-try [_ & body :as form] env)

parse-var clj

(parse-var [_ var :as form] env)

specials clj

Set of special forms common to every clojure variant

valid-binding-symbol? clj

(valid-binding-symbol? s)

validate-bindings clj

(validate-bindings [op bindings & _ :as form] env)

var? clj

(var? obj)

Returns true if obj represent a var form as returned by create-var

wrapping-meta clj

(wrapping-meta {:keys [form env] :as expr})