skeptic.analysis.annotate.api — org.clojars.nomicflux/skeptic 0.9.0-rc1

analyzed-def-entry clj

(analyzed-def-entry ns-sym analyzed)

Inputs: [ns-sym :- (s/maybe s/Symbol) analyzed :- aas/AnnotatedNode] Returns: (s/maybe [(s/one s/Symbol "sym") (s/one AnalyzedDefEntry "entry")])

AnalyzedDefEntry clj

Strict shape of the data side of analyzed-def-entry's tuple. :type is mandatory: a def's value-node MUST carry a :type after the annotator pass. A missing :type means the responsible annotator handler failed to assign a Type, which is a contract violation surfaced as a thrown exception inside analyzed-def-entry.

AnnotateCtx clj

annotated-nodes clj

(annotated-nodes node)

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

arglist-types clj

(arglist-types node arity)

Inputs: [node :- aas/AnnotatedNode arity :- s/Any] Returns: s/Any

binding-init clj

(binding-init holder)

Inputs: [holder :- aas/BindingHolder] Returns: (s/maybe aas/AnnotatedNode)

bottom clj

(bottom ctx)

Inputs: [ctx] Returns: at/SemanticType

branch-origin-kind clj

(branch-origin-kind node)

Inputs: [node :- aas/AnnotatedNode] Returns: (s/maybe s/Keyword)

branch-test-assumption clj

(branch-test-assumption node)

Inputs: [node :- aas/AnnotatedNode] Returns: (s/maybe aos/Assumption)

call-actual-argtypes clj

(call-actual-argtypes node)

Inputs: [node :- aas/CallNode] Returns: [at/SemanticType]

call-args clj

(call-args node)

Inputs: [node :- (s/conditional (fn* [p1__12764#] (= :invoke (:op p1__12764#))) aas/InvokeNode (fn* [p1__12765#] (= :static-call (:op p1__12765#))) aas/StaticCallNode (fn* [p1__12766#] (= :instance-call (:op p1__12766#))) aas/InstanceCallNode)] Returns: [aas/AnnotatedNode]

call-expected-argtypes clj

(call-expected-argtypes node)

Inputs: [node :- aas/CallNode] Returns: [at/SemanticType]

call-fn-node clj

(call-fn-node node)

Inputs: [node :- aas/InvokeNode] Returns: aas/AnnotatedNode

call-node? clj

(call-node? node)

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

call-refs clj

(call-refs node)

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

callee-ref clj

(callee-ref node)

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

case-test-node? clj

(case-test-node? node)

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

const-nil? clj

(const-nil? node)

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

const-node? clj

(const-node? node)

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

const-or-quote? clj

(const-or-quote? node)

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

current-loop-id-key clj

Skeptic-owned ctx key carrying the current enclosing loop's stamped id. Producers: annotate-loop mints and binds; annotate-recur reads.

def-init-node clj

(def-init-node node)

Inputs: [node :- aas/DefNode] Returns: (s/maybe aas/AnnotatedNode)

def-node? clj

(def-node? node)

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

def-value-node clj

(def-value-node node)

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

dyn clj

(dyn ctx)

Inputs: [ctx] Returns: at/SemanticType

else-node clj

(else-node node)

Inputs: [node :- aas/IfNode] Returns: aas/AnnotatedNode

exact-value-type clj

(exact-value-type ctx value)

Inputs: [ctx value] Returns: at/SemanticType

find-node clj

(find-node root pred)

Inputs: [root :- aas/AnnotatedNode pred :- s/Any] Returns: s/Any

fn-node? clj

(fn-node? node)

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

function-methods clj

(function-methods node)

Inputs: [node :- aas/FnNode] Returns: [aas/AnnotatedNode]

if-node? clj

(if-node? node)

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

invoke-like? clj

(invoke-like? node)

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

invoke-node? clj

(invoke-node? node)

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

invoke-ops clj

let-node? clj

(let-node? node)

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

local-node? clj

(local-node? node)

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

local-resolution-path clj

(local-resolution-path local-node)

Inputs: [local-node :- aas/AnnotatedNode] Returns: s/Any

local-vars-context clj

(local-vars-context node)

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

local-with-init? clj

(local-with-init? node)

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

loop-id-key clj

Skeptic-owned key stamped on annotated :recur nodes by annotate-recur, identifying the annotate-loop / annotate-fn-method pass that produced them. Does not depend on the analyzer's :loop-id field (clj-only).

loop-recur-id clj

(loop-recur-id node)

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

Read the Skeptic-stamped loop id from a :recur node. Returns nil for unannotated recurs (structure-shared subtrees not visited by this pass).

method-body clj

(method-body node)

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

method-result-type clj

(method-result-type method)

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

node-bindings clj

(node-bindings node)

Inputs: [node :- (s/conditional (fn* [p1__12638#] (= :let (:op p1__12638#))) aas/LetNode (fn* [p1__12639#] (= :loop (:op p1__12639#))) aas/LoopNode)] Returns: [aas/AnnotatedNode]

node-body clj

(node-body node)

Inputs: [node :- (s/conditional (fn* [p1__12575#] (= :let (:op p1__12575#))) aas/LetNode (fn* [p1__12576#] (= :loop (:op p1__12576#))) aas/LoopNode (fn* [p1__12577#] (= :fn-method (:op p1__12577#))) aas/FnMethodNode)] Returns: aas/AnnotatedNode

node-children clj

(node-children node)

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

node-class clj

(node-class node)

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

node-fn-type clj

(node-fn-type node)

Inputs: [node :- aas/AnnotatedNode] Returns: (s/maybe at/SemanticType)

node-form clj

(node-form node)

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

node-fun-type clj

(node-fun-type node)

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

node-info clj

(node-info node)

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

node-info-name clj

(node-info-name node)

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

cljs :var op nodes carry the fully-qualified call symbol at :info :name (e.g. 'cljs.core/apply). JVM :var op nodes carry the resolved Var at :var instead. Returns nil for JVM nodes.

node-init clj

(node-init node)

Inputs: [node :- (s/conditional (fn* [p1__12608#] (= :binding (:op p1__12608#))) aas/BindingNode (fn* [p1__12609#] (= :def (:op p1__12609#))) aas/DefNode)] Returns: (s/maybe aas/AnnotatedNode)

node-instance-target clj

(node-instance-target node)

Inputs: [node :- aas/InstanceOfNode] Returns: aas/AnnotatedNode

node-keyword clj

(node-keyword node)

Inputs: [node :- aas/KeywordInvokeNode] Returns: aas/AnnotatedNode

node-location clj

(node-location node)

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

node-method clj

(node-method node)

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

node-name clj

(node-name node)

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

node-op clj

(node-op node)

Inputs: [node :- aas/AnnotatedNode] Returns: s/Keyword

node-origin clj

(node-origin node)

Inputs: [node :- aas/AnnotatedNode] Returns: (s/maybe aos/Origin)

node-output-type clj

(node-output-type node)

Inputs: [node :- aas/AnnotatedNode] Returns: (s/maybe at/SemanticType)

node-raw-forms clj

(node-raw-forms node)

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

node-ref clj

(node-ref node)

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

node-tag clj

(node-tag node)

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

node-target clj

(node-target node)

Inputs: [node :- aas/KeywordInvokeNode] Returns: aas/AnnotatedNode

node-test clj

(node-test node)

Inputs: [node :- aas/IfNode] Returns: aas/AnnotatedNode

node-type clj

(node-type node)

Inputs: [node :- aas/AnnotatedNode] Returns: (s/maybe at/SemanticType)

node-value clj

(node-value node)

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

node-var clj

(node-var node)

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

normalize-type clj

(normalize-type ctx value)

Inputs: [ctx value] Returns: at/SemanticType

quote-node? clj

(quote-node? node)

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

recur-args clj

(recur-args node)

Inputs: [node :- aas/RecurNode] Returns: [aas/AnnotatedNode]

recur-node? clj

(recur-node? node)

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

resolved-def-output-type clj

(resolved-def-output-type resolved-defs sym)

Inputs: [resolved-defs :- s/Any sym :- s/Any] Returns: s/Any

stable-identity-node? clj

(stable-identity-node? node)

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

True for any node that names a stable identity for narrowing purposes: lexical locals, top-level vars, and var-ref forms.

static-call-node? clj

(static-call-node? node)

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

strip-derived-types clj

(strip-derived-types value)

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

synthetic-binding-node clj

(synthetic-binding-node idx sym)

Inputs: [idx :- s/Any sym :- s/Any] Returns: aas/AnnotatedNode

then-node clj

(then-node node)

Inputs: [node :- aas/IfNode] Returns: aas/AnnotatedNode

typed-call-metadata-only? clj

(typed-call-metadata-only? node)

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

unwrap-with-meta clj

(unwrap-with-meta node)

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

with-loop-id clj

(with-loop-id node id)

Inputs: [node :- aas/AnnotatedNode id :- s/Any] Returns: aas/AnnotatedNode

with-type clj

(with-type node type)

Inputs: [node :- aas/AnnotatedNode type :- at/SemanticType] Returns: s/Any

Public setter for the inferred value-type of an annotated node. Use this (not raw (assoc node :type ...)) from any code that does not own node shape.