typed.clj.analyzer — org.typedclojure/typed.clj.analyzer 1.2.1

*parse-deftype-with-existing-class* clj

If true, don't generate a new class when analyzing deftype* if a class of the same name already exists.

-deftype clj

(-deftype cname class-name args interfaces)

analyze clj

(analyze form)

(analyze form env)

(analyze form env opts)

Analyzes a clojure form using tools.analyzer augmented with the JVM specific special ops and returns its AST, after running #'run-passes on it.

If no configuration option is provides, analyze will setup tools.analyzer using the extension points declared in this namespace.

If provided, opts should be a map of options to analyze, currently the only valid options are :bindings and :passes-opts (if not provided, :passes-opts defaults to the value of default-passes-opts). If provided, :bindings should be a map of Var->value pairs that will be merged into the default bindings for tools.analyzer, useful to provide custom extension points. If provided, :passes-opts should be a map of pass-name-kw->pass-config-map pairs that can be used to configure the behaviour of each pass.

E.g. (analyze form env {:bindings {#'ana/macroexpand-1 my-mexpand-1}})

analyze+eval clj

(analyze+eval form)

(analyze+eval form env)

(analyze+eval form
              env
              {:keys [additional-gilardi-condition eval-fn annotate-do
                      statement-opts-fn stop-gildardi-check analyze-fn]
               :or {additional-gilardi-condition (fn [form env] true)
                    eval-fn eval-ast
                    annotate-do (fn [a _ _] a)
                    statement-opts-fn identity
                    stop-gildardi-check (fn [form env] false)
                    analyze-fn analyze}
               :as opts})

Like analyze but evals the form after the analysis and attaches the returned value in the :result field of the AST node.

If evaluating the form will cause an exception to be thrown, the exception will be caught and wrapped in an ExceptionThrown object, containing the exception in the e field and the AST in the ast field.

The ExceptionThrown object is then passed to handle-evaluation-exception, which by defaults throws the original exception, but can be used to provide a replacement return value for the evaluation of the AST.

Unrolls do forms to handle the Gilardi scenario.

Useful when analyzing whole files/namespaces.

analyze-method-impls clj

(analyze-method-impls [method [this & params :as args] & body :as form] env)

analyze-outer clj

(analyze-outer ast)

If ast is :unanalyzed, then call analyze-form on it, otherwise returns ast.

create-var clj

(create-var sym {:keys [ns]})

Creates a Var for sym and returns it. The Var gets interned in the env namespace.

current-ns-name clj

(current-ns-name env)

Returns the current namespace symbol.

default-passes clj

Set of passes that will be run by default on the AST by #'run-passes

default-passes-opts clj

Default :passes-opts for analyze

default-thread-bindings clj

(default-thread-bindings env)

desugar-host-expr clj

(desugar-host-expr form env)

desugar-symbol clj

(desugar-symbol form env)

empty-env clj

(empty-env)

Returns an empty env map

eval-ast clj

(eval-ast a
          {:keys [handle-evaluation-exception]
           :or {handle-evaluation-exception throw!}
           :as opts})

eval-ast2 clj

(eval-ast2 ast)

Evaluate an AST node, attaching result to :result.

global-env clj

(global-env)

macroexpand-1 clj

(macroexpand-1 form)

(macroexpand-1 form env)

If form represents a macro form or an inlineable function, returns its expansion, else returns form.

parse clj

parse-case* clj

(parse-case* [_ expr shift mask default case-map switch-type test-type &
              [skip-check?] :as form]
             env)

parse-deftype* clj

(parse-deftype* [_ name class-name fields _ interfaces & methods :as form] env)

parse-import* clj

(parse-import* [_ class :as form] env)

parse-monitor-enter clj

(parse-monitor-enter [_ target :as form] env)

parse-monitor-exit clj

(parse-monitor-exit [_ target :as form] env)

parse-opts+methods clj

(parse-opts+methods methods)

parse-reify* clj

(parse-reify* [_ interfaces & methods :as form] env)

qualify-arglists clj

(qualify-arglists arglists)

resolve-ns clj

(resolve-ns ns-sym {:keys [ns]})

Resolves the ns mapped by the given sym in the global env

resolve-op-sym clj

(resolve-op-sym form env)

Alpha - subject to change

In environment env, if form is an invocation of a global var, return the fully qualified symbol of that var.

resolve-sym clj

(resolve-sym sym {:keys [ns locals] :as env})

Resolves the value mapped by the given sym in the global env If sym is shadowed by a local in env, returns nil.

scheduled-default-passes clj

specials clj

Set of the special forms for clojure in the JVM

unanalyzed clj

(unanalyzed form env)

var->sym clj

(var->sym v)

If given a var, returns the fully qualified symbol for that var, otherwise nil.