skeptic.analysis.calls — org.clojars.nomicflux/skeptic 0.8.0

assoc-call-syms clj

assoc-call? clj

(assoc-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

blank-call-syms clj

blank-call? clj

(blank-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

butlast-call-syms clj

butlast-call? clj

(butlast-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

call-info clj

(call-info ctx fn-node args)

Inputs: [ctx :- s/Any fn-node :- s/Any args :- s/Any] Returns: s/Any

chunk-first-call-syms clj

chunk-first-call? clj

(chunk-first-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

concat-call-syms clj

concat-call? clj

(concat-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

contains-call-syms clj

contains-call? clj

(contains-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

default-call-info clj

(default-call-info ctx arity output)

Inputs: [ctx :- s/Any arity :- s/Int output :- (s/maybe ats/SemanticType)] Returns: s/Any

dissoc-call-syms clj

dissoc-call? clj

(dissoc-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

drop-call-syms clj

drop-call? clj

(drop-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

drop-last-call-syms clj

drop-last-call? clj

(drop-last-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

drop-while-call-syms clj

drop-while-call? clj

(drop-while-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

equality-call-syms clj

equality-call? clj

(equality-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

first-call-syms clj

first-call? clj

(first-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

fun-type->call-opts clj

(fun-type->call-opts fun-type)

Inputs: [fun-type :- ats/SemanticType] Returns: s/Any

get-call-syms clj

get-call? clj

(get-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

get-key-query clj

(get-key-query ctx node)

Inputs: [ctx :- s/Any node :- s/Any] Returns: s/Any

inc-invoke-syms clj

inc-invoke? clj

(inc-invoke? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

instance-call-syms clj

into-call-syms clj

into-call? clj

(into-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

keyword-invoke-kw-and-target clj

(keyword-invoke-kw-and-target node)

Inputs: [node :- s/Any] Returns: (s/maybe [(s/one s/Keyword "kw") (s/one s/Any "target")])

When keyword-invoke-on-local?, returns [kw-keyword target-node].

keyword-invoke-on-local? clj

(keyword-invoke-on-local? node)

Inputs: [node :- s/Any] Returns: s/Bool

True for (:k x) as either JVM analyzer :invoke or :keyword-invoke.

last-call-syms clj

last-call? clj

(last-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

literal-map-key? clj

(literal-map-key? node)

Inputs: [node :- s/Any] Returns: s/Bool

literal-node-value clj

(literal-node-value node)

Inputs: [node :- s/Any] Returns: s/Any

lookup-summary clj

(lookup-summary accessor-summaries ns-sym node)

Inputs: [accessor-summaries :- s/Any ns-sym :- (s/maybe s/Symbol) node :- s/Any] Returns: s/Any

lookup-type clj

(lookup-type dict ns-sym node)

Inputs: [dict :- s/Any ns-sym :- (s/maybe s/Symbol) node :- s/Any] Returns: s/Any

map-literal-key-type clj

(map-literal-key-type ctx node)

Inputs: [ctx :- s/Any node :- s/Any] Returns: ats/SemanticType

merge-call-syms clj

merge-call? clj

(merge-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

minus-invoke-syms clj

minus-invoke? clj

(minus-invoke? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

multiply-invoke-syms clj

multiply-invoke? clj

(multiply-invoke? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

node-info clj

(node-info node)

Inputs: [node :- s/Any] Returns: s/Any

not-call-syms clj

not-call? clj

(not-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

nth-call-syms clj

nth-call? clj

(nth-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

plus-invoke-syms clj

plus-invoke? clj

(plus-invoke? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

qualify-symbol clj

(qualify-symbol ns-sym sym)

Inputs: [ns-sym :- s/Any sym :- s/Any] Returns: s/Any

resolved-call-sym clj

(resolved-call-sym fn-node)

Inputs: [fn-node :- s/Any] Returns: (s/maybe s/Symbol)

rest-call-syms clj

rest-call? clj

(rest-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

second-call-syms clj

second-call? clj

(second-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

seq-call-syms clj

seq-call? clj

(seq-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

static-assoc-call? clj

(static-assoc-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

static-contains-call? clj

(static-contains-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

static-dissoc-call? clj

(static-dissoc-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

static-equality-call? clj

(static-equality-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

static-get-call? clj

(static-get-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

static-merge-call? clj

(static-merge-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

static-nil?-call? clj

(static-nil?-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

static-nil?-target clj

(static-nil?-target node)

Inputs: [node :- s/Any] Returns: (s/maybe s/Any)

static-update-call? clj

(static-update-call? node)

Inputs: [node :- s/Any] Returns: s/Bool

take-call-syms clj

take-call? clj

(take-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

take-while-call-syms clj

take-while-call? clj

(take-while-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

type-predicate-assumption-info clj

(type-predicate-assumption-info fn-node args)

Inputs: [fn-node :- s/Any args :- [s/Any]] Returns: (s/maybe aos/PredInfo)

type-predicate-assumption-info-for-sym clj

(type-predicate-assumption-info-for-sym sym args)

Inputs: [sym :- (s/maybe s/Symbol) args :- [s/Any]] Returns: (s/maybe aos/PredInfo)

type-predicate-call? clj

(type-predicate-call? fn-node args)

Inputs: [fn-node :- s/Any args :- [s/Any]] Returns: s/Bool

typed-callable? clj

(typed-callable? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

update-call-syms clj

update-call? clj

(update-call? fn-node)

Inputs: [fn-node :- s/Any] Returns: s/Bool

var->sym clj

(var->sym var)

Inputs: [var :- s/Any] Returns: (s/maybe s/Symbol)