A program, not a folder of files
Swift Analyzer starts with a compiler-produced Index Store and a manifest that identifies one exact build. It reasons across declarations, references, explicit roots, module worlds, and modeled dispatch instead of inspecting files in isolation.
The result is a whole-program reachability view: what is definitely connected, what may be retained by a boundary, and where the available evidence is not enough to decide.
Trace reachability
Follow semantic relationships from explicit roots through the validated snapshot.
Surface unused candidates
Identify declarations eligible for an advisory repository-unused result when the required evidence is complete.
Preserve unknowns
Keep incomplete or unmodeled boundaries visible instead of converting silence into certainty.
From build evidence to an answer
The workflow is deliberately inspectable. Validate the snapshot before analysis, scan it locally, then ask why for an exact result. The same identities and outcomes remain available to automation as canonical JSON.
1. Validate
doctor checks the manifest, toolchain profile, compiler data, and requested capability before a scan is trusted.
2. Scan
scan builds the reachability view and emits structured advisory results for the selected snapshot.
3. Ask why
why explains one exact subject without guessing from a name or source location.
Every result can explain itself
A result is more useful when it carries the reason behind it. Swift Analyzer keeps identity, scope, evidence, and limitations together so a developer can review the conclusion instead of accepting a bare warning.
The absence of known references does not prove that code is unused. Missing world, index, source, or dynamic coverage keeps the affected conclusion unknown; incomplete capability is reported as incomplete, not as a clean scan.
Exact identity
Explanations target the same canonical subject that appeared in the scan.
Bounded evidence
The evidence supporting a conclusion remains reviewable and tied to its snapshot.
Honest outcomes
Definite, retained, unknown, and incomplete states keep distinct meanings.
Built for real Swift boundaries
Swift reachability is wider than direct calls. Roots, module worlds, dispatch, generated inputs, and dynamic behavior all affect what can be concluded from a build.
Swift Analyzer models the supported relationships and narrows uncertainty to the affected conclusion when required evidence is absent. It does not turn an incomplete model into permission to delete code.
A semantic layer beside familiar tools
SwiftLint and SwiftFormat make Swift source consistent at the style and formatting layers. Swift Analyzer works at a different layer: relationships that become visible only when one build snapshot is considered as a program.
It complements those tools with local reachability, evidence-backed explanations, conservative unknown boundaries, and structured output. The current capability remains advisory-only for one exact validated profile.