skeptic.analysis.calls — org.clojars.nomicflux/skeptic 0.9.0-rc1

*user-fn-path-predicate-summaries* clj

Project-scoped registry {qualified-sym → {:pred kw [:class C] :path [kw ...]}} recognising user-defined fns whose body reduces to a built-in path-type-predicate on a destructured key of their first parameter. Bound by skeptic.checking.pipeline/check-ns from project-state; read by skeptic.analysis.origin/test->assumption so calls like (b-params? params) propagate as (vector?, [:k], _) narrowing on params.

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

CallOpts clj

CallOptsArglistEntry clj

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 at/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 :- at/SemanticType] Returns: CallOpts

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: at/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

path-predicate-summary-from-form clj

(path-predicate-summary-from-form form)

Returns {:pred kw :path [kw]} when form is (s/defn name [doc?] [attr-map?] :- s/Bool [{:keys [...]} :- _] (PRED k)) where PRED is a recognised built-in single-arg type predicate and k is one of the destructured :keys. Returns nil otherwise. Only the single-arity, single-body shape is recognised; multi-arity, attr maps with metadata other than the schema marker, and predicates not in the built-in registry fall through.

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

type-predicate-sym->pred clj

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

user-fn-path-predicate-info clj

(user-fn-path-predicate-info sym)

Inputs: [sym :- (s/maybe s/Symbol)] Returns: (s/maybe #:s{Keyword s/Any})

Lookup helper for *user-fn-path-predicate-summaries*.

var->sym clj

(var->sym var)

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