skeptic.checking.pipeline — org.clojars.nomicflux/skeptic 0.9.0-rc1

AccessorPathElem clj

AccessorSummaries clj

AccessorSummary clj

analyze-source-exprs clj

(analyze-source-exprs dict
                      ns-sym
                      source-file
                      exprs
                      accessor-summaries
                      cljs-state
                      lang)

Inputs: [dict ns-sym source-file exprs accessor-summaries :- #:s{Any s/Any} cljs-state :- #:s{Any s/Any} lang :- (s/enum :clj :cljs :both)] Returns: s/Any

analyzed-def-entry clj

(analyzed-def-entry ns-sym analyzed)

Inputs: [ns-sym :- (s/maybe s/Symbol) analyzed :- aas/AnnotatedNode] Returns: (s/maybe PipelineDefEntry)

block-in-ns clj macro

(block-in-ns _ns file & body)

check-namespace clj

(check-namespace project-state ns-sym source-file form-opts)

Inputs: [project-state ns-sym :- s/Symbol source-file form-opts] Returns: s/Any

Owns the full per-namespace run: :load (require), :declaration + :read + :expression (typed declarations and form checking). Returns {:results [...] :provenance {sym → Provenance}}.

check-ns clj

(check-ns project-state ns source-file form-opts)

Inputs: [project-state ns :- s/Symbol source-file form-opts] Returns: s/Any

check-ns-form clj

(check-ns-form dict
               ignore-body
               ns
               source-file
               source-form
               accessor-summaries
               cljs-state
               lang
               opts)

Inputs: [dict ignore-body :- #{s/Symbol} ns :- s/Symbol source-file source-form accessor-summaries :- #:s{Any s/Any} cljs-state :- #:s{Any s/Any} lang :- (s/enum :clj :cljs :both) opts] Returns: s/Any

check-resolved-form clj

(check-resolved-form
  dict
  ignore-body
  ns-sym
  source-file
  source-form
  analyzed
  {:keys [keep-empty remove-context debug] :or {keep-empty false} :as opts})

Inputs: [dict ignore-body :- #{s/Symbol} ns-sym :- s/Symbol source-file source-form analyzed :- aas/AnnotatedNode {:keys [keep-empty remove-context debug], :or {keep-empty false}, :as opts} :- copts/FormCheckOpts] Returns: s/Any

CljsCachedFormEntry clj

Shape of a single cached CLJS form entry under cljs-state[source-file] :entries.

CljsPassResults clj

def-output-results clj

(def-output-results dict ns-sym source-file source-form enclosing-form node)

Inputs: [dict ns-sym source-file source-form enclosing-form node :- aas/AnnotatedNode] Returns: s/Any

enclosing-form clj

(enclosing-form ns-sym source-form)

Inputs: [ns-sym :- (s/maybe s/Symbol) source-form] Returns: s/Any

expression-exception-result clj

(expression-exception-result ns-sym source-file source-form e lang)

Inputs: [ns-sym :- (s/maybe s/Symbol) source-file source-form e :- Throwable lang :- (s/enum :clj :cljs :both)] Returns: s/Any

FiniteValue clj

A literal value extracted from a ValueT Type's :value slot — i.e., the finite values a Skeptic-known function can return when its output type is a union of s/eq/:= constants. The realistic dispatch case is enum-like primitives. Extending to collection-valued literals ((s/eq [:a :b])) requires adding the collection variant here, not widening callers to s/Any.

input-cast-result clj

(input-cast-result enclosing-form node error-groups)

Inputs: [enclosing-form node :- aas/AnnotatedNode error-groups] Returns: s/Any

input-error-group clj

(input-error-group expr arg-node expected actual)

Inputs: [expr arg-node :- (s/maybe aas/AnnotatedNode) expected :- at/SemanticType actual :- at/SemanticType] Returns: s/Any

lang-of-source-file clj

(lang-of-source-file source-file)

(lang-of-source-file opts source-file)

.cljs → :cljs. .cljc → :both. Anything else (.clj or no source-file) → :clj.

Two-arity form applies --cljs-disable: :cljs and :both collapse to :clj (i.e. drop the :cljs reader-conditional branch from .cljc). Pure .cljs files are expected to be filtered at the discovery layer in core/check-project before reaching here.

load-exception-result clj

(load-exception-result ns-sym e)

Inputs: [ns-sym :- s/Symbol e :- Throwable] Returns: s/Any

match-s-exprs clj

(match-s-exprs enclosing-form node keep-empty)

Inputs: [enclosing-form node :- aas/AnnotatedNode keep-empty :- s/Bool] Returns: s/Any

method-output-type clj

(method-output-type method)

Inputs: [method :- aas/AnnotatedNode] Returns: at/SemanticType

namespace-dict clj

(namespace-dict opts ns-sym source-file lang cljs-state var-provs form-refs)

Inputs: [opts ns-sym :- s/Symbol source-file lang cljs-state var-provs form-refs] Returns: s/Any

next-checkable-form clj

(next-checkable-form reader)

Inputs: [reader] Returns: s/Any

ns-exprs clj

(ns-exprs source-file)

Inputs: [source-file] Returns: s/Any

PipelineDefEntry clj

Output of pipeline-local analyzed-def-entry and input/output of enrich-summary-with-declared-output. The :entry field reuses the strict aapi/AnalyzedDefEntry, so :entry's :type is mandatory.

preload-cljs-state! clj

(preload-cljs-state! cljs-disable? loaded)

Parse and analyze every source-file requiring cljs analysis (.cljs or .cljc). Each file is read and analyzed once through a file-local cljs analyzer state so the cljs reader sees analyzer aliases and cljs data readers. Returns {File → {:ns-ast ns-ast :entries [{:source-form :ast}] :asts [ast …]}} — empty when cljs-disable? is truthy or loaded contains no cljs/cljc sources. The compiler state does not escape the analyzer driver; downstream phases consume only cached entries.

project-discovery clj

(project-discovery nss-with-source-files)

project-state clj

(project-state opts all-discovered-nss)

Inputs: [opts all-discovered-nss :- copts/DiscoveredNamespaces] Returns: s/Any

Source-of-truth for the project pass: per-ns admission once, dicts merged into a project-wide dict; accessor summaries collected per-ns against the merged dict; conditional descriptors enriched once on the merged dict. Returns {:dict <enriched-merged> :accessor-summaries <merged> :per-ns {ns-sym {:ignore-body :errors :provenance}}}. Threaded into every per-namespace check so cross-namespace var resolution and conditional discriminators ride the same project pass.

all-discovered-nss MUST be the complete discovered namespace map for the project, not a subset. Pre-filtering it by :namespace / -n silently drops cross-namespace declarations: call sites in the requested namespace that depend on schemas declared elsewhere would fall back to Dyn and produce no finding. -n is a CHECKING filter and must be applied in skeptic.core/check-project against the per-ns iteration loop, never here.

When loaded includes .cljs or .cljc source-files, each is read and analyzed independently via the cljs analyzer driver and the results are carried as a local cljs-state map (source-file → {:ns-ast :entries :asts}) — threaded into per-ns admission/checking and stored on the returned ProjectState. Per-ns admission/analysis dispatches on the per-source-file lang carried in each loaded triple.

project-var-provs clj

(project-var-provs opts project-disc)

read-exception-result clj

(read-exception-result source-file e)

Inputs: [source-file e :- Throwable] Returns: s/Any