Struct AnalysisResults 

pub struct AnalysisResults {

    pub unused_files: Vec<UnusedFileFinding>,
    pub unused_exports: Vec<UnusedExportFinding>,
    pub unused_types: Vec<UnusedTypeFinding>,
    pub private_type_leaks: Vec<PrivateTypeLeakFinding>,
    pub unused_dependencies: Vec<UnusedDependencyFinding>,
    pub unused_dev_dependencies: Vec<UnusedDevDependencyFinding>,
    pub unused_optional_dependencies: Vec<UnusedOptionalDependencyFinding>,
    pub unused_enum_members: Vec<UnusedEnumMemberFinding>,
    pub unused_class_members: Vec<UnusedClassMemberFinding>,
    pub unused_store_members: Vec<UnusedStoreMemberFinding>,
    pub unresolved_imports: Vec<UnresolvedImportFinding>,
    pub unlisted_dependencies: Vec<UnlistedDependencyFinding>,
    pub duplicate_exports: Vec<DuplicateExportFinding>,
    pub type_only_dependencies: Vec<TypeOnlyDependencyFinding>,
    pub test_only_dependencies: Vec<TestOnlyDependencyFinding>,
    pub circular_dependencies: Vec<CircularDependencyFinding>,
    pub re_export_cycles: Vec<ReExportCycleFinding>,
    pub boundary_violations: Vec<BoundaryViolationFinding>,
    pub boundary_coverage_violations: Vec<BoundaryCoverageViolationFinding>,
    pub boundary_call_violations: Vec<BoundaryCallViolationFinding>,
    pub policy_violations: Vec<PolicyViolationFinding>,
    pub stale_suppressions: Vec<StaleSuppression>,
    pub unused_catalog_entries: Vec<UnusedCatalogEntryFinding>,
    pub empty_catalog_groups: Vec<EmptyCatalogGroupFinding>,
    pub unresolved_catalog_references: Vec<UnresolvedCatalogReferenceFinding>,
    pub unused_dependency_overrides: Vec<UnusedDependencyOverrideFinding>,
    pub misconfigured_dependency_overrides: Vec<MisconfiguredDependencyOverrideFinding>,
    pub invalid_client_exports: Vec<InvalidClientExportFinding>,
    pub mixed_client_server_barrels: Vec<MixedClientServerBarrelFinding>,
    pub misplaced_directives: Vec<MisplacedDirectiveFinding>,
    pub unprovided_injects: Vec<UnprovidedInjectFinding>,
    pub unrendered_components: Vec<UnrenderedComponentFinding>,
    pub route_collisions: Vec<RouteCollisionFinding>,
    pub dynamic_segment_name_conflicts: Vec<DynamicSegmentNameConflictFinding>,
    pub unused_component_props: Vec<UnusedComponentPropFinding>,
    pub unused_component_emits: Vec<UnusedComponentEmitFinding>,
    pub unused_component_inputs: Vec<UnusedComponentInputFinding>,
    pub unused_component_outputs: Vec<UnusedComponentOutputFinding>,
    pub unused_svelte_events: Vec<UnusedSvelteEventFinding>,
    pub unused_server_actions: Vec<UnusedServerActionFinding>,
    pub unused_load_data_keys: Vec<UnusedLoadDataKeyFinding>,
    pub unused_load_data_keys_global_abstain: bool,
    pub prop_drilling_chains: Vec<PropDrillingChainFinding>,
    pub thin_wrappers: Vec<ThinWrapperFinding>,
    pub duplicate_prop_shapes: Vec<DuplicatePropShapeFinding>,
    pub suppression_count: usize,
    pub active_suppressions: Vec<ActiveSuppression>,
    pub feature_flags: Vec<FeatureFlag>,
    pub security_findings: Vec<SecurityFinding>,
    pub security_unresolved_edge_files: usize,
    pub security_unresolved_callee_sites: usize,
    pub security_unresolved_callee_diagnostics: Vec<SecurityUnresolvedCalleeDiagnostic>,
    pub export_usages: Vec<ExportUsage>,
    pub entry_point_summary: Option<EntryPointSummary>,
    pub render_fan_in: Option<RenderFanInMetric>,
}

Complete analysis results.

Examples

use fallow_types::output_dead_code::UnusedFileFinding;
use fallow_types::results::{AnalysisResults, UnusedFile};
use std::path::PathBuf;

let mut results = AnalysisResults::default();
assert_eq!(results.total_issues(), 0);
assert!(!results.has_issues());

results
    .unused_files
    .push(UnusedFileFinding::with_actions(UnusedFile {
        path: PathBuf::from("src/dead.ts"),
    }));
assert_eq!(results.total_issues(), 1);
assert!(results.has_issues());

Fields

unused_files: Vec<UnusedFileFinding>

Files not reachable from any entry point. Wrapped in UnusedFileFinding so each entry carries a typed actions array natively, replacing the pre-2.76 post-pass injection.

unused_exports: Vec<UnusedExportFinding>

Exports never imported by other modules. Wrapped in UnusedExportFinding so each entry carries a typed actions array natively.

unused_types: Vec<UnusedTypeFinding>

Type exports never imported by other modules. Wrapped in UnusedTypeFinding: the inner UnusedExport struct is shared with unused_exports but the wrapper emits a type-targeted fix description.

private_type_leaks: Vec<PrivateTypeLeakFinding>

Exported symbols whose public signature references same-file private types. Wrapped in PrivateTypeLeakFinding so each entry carries a typed actions array natively.

unused_dependencies: Vec<UnusedDependencyFinding>

Dependencies listed in package.json but never imported. Wrapped in UnusedDependencyFinding so each entry carries a typed actions array natively. The fix action swaps from remove-dependency to move-dependency when used_in_workspaces is non-empty.

unused_dev_dependencies: Vec<UnusedDevDependencyFinding>

Dev dependencies listed in package.json but never imported. Wrapped in UnusedDevDependencyFinding: same bare struct as unused_dependencies with a devDependencies-targeted fix description.

unused_optional_dependencies: Vec<UnusedOptionalDependencyFinding>

Optional dependencies listed in package.json but never imported. Wrapped in UnusedOptionalDependencyFinding with an optionalDependencies-targeted fix description.

unused_enum_members: Vec<UnusedEnumMemberFinding>

Enum members never accessed. Wrapped in UnusedEnumMemberFinding so each entry carries a typed actions array natively.

unused_class_members: Vec<UnusedClassMemberFinding>

Class members never accessed. Wrapped in UnusedClassMemberFinding: same inner UnusedMember struct as unused_enum_members, with a class-targeted fix description and the auto_fixable: false default to reflect dependency-injection patterns.

unused_store_members: Vec<UnusedStoreMemberFinding>

Store members (Pinia state / getters / actions key, or a setup-store returned key) declared but never accessed by any consumer project-wide. Wrapped in UnusedStoreMemberFinding: same inner UnusedMember struct as unused_class_members, with a store-targeted fix description. Cross-graph: the store binding is imported (the module is reachable) yet a specific member is dead.

unresolved_imports: Vec<UnresolvedImportFinding>

Import specifiers that could not be resolved. Wrapped in UnresolvedImportFinding so each entry carries a typed actions array natively.

unlisted_dependencies: Vec<UnlistedDependencyFinding>

Dependencies used in code but not listed in package.json. Wrapped in UnlistedDependencyFinding.

duplicate_exports: Vec<DuplicateExportFinding>

Exports with the same name across multiple modules. Wrapped in DuplicateExportFinding so each entry carries a typed actions array natively, with the position-0 add-to-config ignoreExports snippet wired in at wrapper construction.

type_only_dependencies: Vec<TypeOnlyDependencyFinding>

Production dependencies only used via type-only imports (could be devDependencies). Only populated in production mode. Wrapped in TypeOnlyDependencyFinding.

test_only_dependencies: Vec<TestOnlyDependencyFinding>

Production dependencies only imported by test files (could be devDependencies). Wrapped in TestOnlyDependencyFinding.

circular_dependencies: Vec<CircularDependencyFinding>

Circular dependency chains detected in the module graph. Wrapped in CircularDependencyFinding so each entry carries a typed actions array natively.

re_export_cycles: Vec<ReExportCycleFinding>

Cycles or self-loops in the re-export edge subgraph (barrel files re-exporting from each other in a loop). Wrapped in ReExportCycleFinding so each entry carries a typed actions array natively (a refactor-re-export-cycle informational primary plus a suppress-file secondary; cycles are file-scoped so a single suppression breaks the cycle).

boundary_violations: Vec<BoundaryViolationFinding>

Imports that cross architecture boundary rules. Wrapped in BoundaryViolationFinding so each entry carries a typed actions array natively.

boundary_coverage_violations: Vec<BoundaryCoverageViolationFinding>

Files that matched no architecture boundary zone while boundaries.coverage.requireAllFiles was enabled.

boundary_call_violations: Vec<BoundaryCallViolationFinding>

Calls from zoned files to callees forbidden for that zone via boundaries.calls.forbidden. Wrapped in BoundaryCallViolationFinding so each entry carries a typed actions array natively.

policy_violations: Vec<PolicyViolationFinding>

Banned calls and banned imports matched by declarative rule packs (rulePacks config). Wrapped in PolicyViolationFinding so each entry carries a typed actions array natively. Each finding carries its effective per-rule severity.

stale_suppressions: Vec<StaleSuppression>

Suppression comments or JSDoc tags that no longer match any issue.

unused_catalog_entries: Vec<UnusedCatalogEntryFinding>

Entries in package manager catalog sections not referenced by any workspace package via the catalog: protocol. Supports pnpm-workspace.yaml catalogs and Bun root package.json catalogs. Wrapped in UnusedCatalogEntryFinding so each entry carries a typed actions array natively, with per-instance auto_fixable derived from hardcoded_consumers and the catalog source file.

empty_catalog_groups: Vec<EmptyCatalogGroupFinding>

Named groups under package manager catalogs sections that declare no package entries. The top-level catalog: map is not reported. Wrapped in EmptyCatalogGroupFinding.

unresolved_catalog_references: Vec<UnresolvedCatalogReferenceFinding>

Workspace package.json references to catalogs (catalog: or catalog:<name>) that do not declare the consumed package. The package manager install will error until the named catalog grows to include the package or the reference is switched / removed. Wrapped in UnresolvedCatalogReferenceFinding with the discriminated add-catalog-entry / update-catalog-reference primary at position 0.

unused_dependency_overrides: Vec<UnusedDependencyOverrideFinding>

Entries in pnpm-workspace.yaml’s overrides: section, or package.json’s pnpm.overrides block, whose target package is not declared by any workspace package and is not present in pnpm-lock.yaml. Default severity is warn because projects without a readable lockfile fall back to manifest-only checks; the hint field flags those conservative cases. Wrapped in UnusedDependencyOverrideFinding.

misconfigured_dependency_overrides: Vec<MisconfiguredDependencyOverrideFinding>

pnpm.overrides entries whose key or value does not parse as a valid override spec (empty key, empty value, malformed selector, unbalanced parent matcher). pnpm install will reject these. Default severity is error. Wrapped in MisconfiguredDependencyOverrideFinding.

invalid_client_exports: Vec<InvalidClientExportFinding>

"use client" files that export a Next.js server-only / route-segment config name (e.g. metadata, revalidate, GET). Next.js rejects this at build time. Wrapped in InvalidClientExportFinding so each entry carries a typed actions array natively. Default severity is warn.

mixed_client_server_barrels: Vec<MixedClientServerBarrelFinding>

Barrel files that re-export BOTH a "use client" origin module AND a server-only origin module (the Next.js App Router footgun). Wrapped in MixedClientServerBarrelFinding so each entry carries a typed actions array natively. Default severity is warn.

misplaced_directives: Vec<MisplacedDirectiveFinding>

"use client" / "use server" directives written as expression statements after a non-directive statement, so the RSC bundler parses them as ordinary strings and silently ignores them. Wrapped in MisplacedDirectiveFinding so each entry carries a typed actions array natively. Default severity is warn.

unprovided_injects: Vec<UnprovidedInjectFinding>

Vue inject(KEY) / Svelte getContext(KEY) calls whose symbol KEY is provided nowhere in the project (the injected-never-provided dead-half). Wrapped in UnprovidedInjectFinding so each entry carries a typed actions array natively. Default severity is warn.

unrendered_components: Vec<UnrenderedComponentFinding>

Vue/Svelte single-file components that are reachable but rendered nowhere (the imported-but-never-rendered dead-half). Wrapped in UnrenderedComponentFinding so each entry carries a typed actions array natively. Default severity is warn.

route_collisions: Vec<RouteCollisionFinding>

Next.js App Router route files that resolve to the same URL within one app-root (a guaranteed next build failure). Wrapped in RouteCollisionFinding so each entry carries a typed actions array natively. One finding per colliding file. Default severity is warn.

dynamic_segment_name_conflicts: Vec<DynamicSegmentNameConflictFinding>

Sibling Next.js dynamic route segments at one tree position using different param spellings (a dev / runtime error; next build does NOT catch it). Wrapped in DynamicSegmentNameConflictFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_props: Vec<UnusedComponentPropFinding>

Vue <script setup> defineProps props referenced nowhere in their own SFC (neither <script> nor <template>). Wrapped in UnusedComponentPropFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_emits: Vec<UnusedComponentEmitFinding>

Vue <script setup> defineEmits events emitted nowhere in their own SFC (no emit('<name>') call). Wrapped in UnusedComponentEmitFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_inputs: Vec<UnusedComponentInputFinding>

Angular @Input() / signal input() / model() inputs read nowhere in their own component (neither the template nor the class body). Wrapped in UnusedComponentInputFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_outputs: Vec<UnusedComponentOutputFinding>

Angular @Output() / signal output() outputs emitted nowhere in their own component (no this.<output>.emit(...)). Wrapped in UnusedComponentOutputFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_svelte_events: Vec<UnusedSvelteEventFinding>

Svelte components dispatching a custom event via createEventDispatcher() whose event name is listened to nowhere project-wide (cross-file dead-output direction). Wrapped in UnusedSvelteEventFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_server_actions: Vec<UnusedServerActionFinding>

Next.js Server Actions (exports of "use server" files) that no code in the project references. Reclassified out of unused_exports for "use server" files. Wrapped in UnusedServerActionFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_load_data_keys: Vec<UnusedLoadDataKeyFinding>

SvelteKit +page.{ts,server.ts,js,server.js} load() return-object keys read by no consumer. Wrapped in UnusedLoadDataKeyFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_load_data_keys_global_abstain: bool

true when the unused-load-data-key detector abstained project-wide because a whole-object use of page.data / $page.data was seen somewhere (S1 observability: an empty unused_load_data_keys with this flag set is NOT a clean bill, it means the rule could not run safely). Serialized only when true so the default JSON contract is unchanged.

prop_drilling_chains: Vec<PropDrillingChainFinding>

React/Preact props forwarded unchanged through >= N intermediate pass-through components until a consumer (located per-chain records). Wrapped in PropDrillingChainFinding so each entry carries a typed actions array natively. Health signal: the rule defaults to off (opt-in), so this is dormant and populated ONLY when the user enables it.

thin_wrappers: Vec<ThinWrapperFinding>

React/Preact components whose entire body is a single spread-forwarded child render (return <Child {...props}/>): pure structural indirection, a candidate for inlining at call sites. Wrapped in ThinWrapperFinding so each entry carries a typed actions array natively. Health signal: the rule defaults to off (opt-in), so this is dormant and populated ONLY when the user enables it.

duplicate_prop_shapes: Vec<DuplicatePropShapeFinding>

React/Preact components that participate in a duplicate-prop-shape group: three or more components across two or more files whose statically-known prop NAME set is identical after stripping ubiquitous DOM / passthrough names (a missing shared Props type / base component). Wrapped in DuplicatePropShapeFinding so each entry carries a typed actions array and its sibling roster natively. Health signal: the rule defaults to off (opt-in), so this is dormant and populated ONLY when the user enables it.

suppression_count: usize

Number of suppression entries that matched an issue during analysis. Human output uses this for the suppression footer; it is skipped in machine output to avoid changing the public JSON issue contract.

active_suppressions: Vec<ActiveSuppression>

Suppression comments present in analyzed files this run (every present marker, all kinds, not only consumed ones). Internal: read in-process by fallow impact to distinguish a genuinely resolved finding from one silenced by a fallow-ignore. Skipped during serialization, like Self::suppression_count, so the public JSON output contract is unchanged.

feature_flags: Vec<FeatureFlag>

Detected feature flag patterns. Advisory output, not included in issue counts. Skipped during default serialization: injected separately in JSON output when enabled.

security_findings: Vec<SecurityFinding>

Local security candidates (e.g. client-server-leak). CANDIDATES for downstream agent verification, NOT verified vulnerabilities. Off by default; populated only when the corresponding security_* rule is enabled (forced on by fallow security). Excluded from total_issues and skipped during serialization so they never surface under bare fallow or the audit gate; the fallow security command reads this field and emits its own envelope. Mirrors Self::feature_flags.

security_unresolved_edge_files: usize

In-band blind-spot count: number of "use client" files whose transitive import cone contains a dynamic import() the reachability BFS cannot follow. Surfaced by fallow security so a leak hidden behind an unresolved edge is never silently reported as “clean”. Skipped during serialization like Self::security_findings.

security_unresolved_callee_sites: usize

In-band blind-spot count: number of sink-shaped nodes the catalogue detector could not flatten to a static callee path (dynamic dispatch, computed members, aliased bindings). Surfaced by fallow security so an empty catalogue result with a non-zero count is not reported as “clean”. Skipped during serialization like Self::security_findings.

security_unresolved_callee_diagnostics: Vec<SecurityUnresolvedCalleeDiagnostic>

Location samples for sink-shaped nodes the catalogue detector could not flatten to a static callee path. Skipped during default serialization; fallow security summarizes this metadata in its own envelope.

export_usages: Vec<ExportUsage>

Usage counts for all exports across the project. Used by the LSP for Code Lens. Not included in issue counts – this is metadata, not an issue type. Skipped during serialization: this is internal LSP data, not part of the JSON output schema.

entry_point_summary: Option<EntryPointSummary>

Summary of detected entry points, grouped by discovery source. Not included in issue counts – this is informational metadata. Skipped during serialization: rendered separately in JSON output.

render_fan_in: Option<RenderFanInMetric>

Per-component render fan-in (JSX render SITES + distinct parents) plus the precomputed concentration aggregates. DESCRIPTIVE blast-radius signal, not an issue type: the component-graph analogue of module fan-in. None on non-React projects (the dep gate fails and render_edges is empty). Skipped during serialization (internal carrier, like Self::export_usages); the public surface is the VitalSigns aggregate, so bare fallow / audit never serialize it. See RenderFanInMetric.

Implementations

impl AnalysisResults

pub const fn total_issues(&self) -> usize

Total number of issues found.

Sums across all issue categories (unused files, exports, types, dependencies, members, unresolved imports, unlisted deps, duplicates, type-only deps, circular deps, and boundary violations).

Examples

use fallow_types::output_dead_code::{UnresolvedImportFinding, UnusedFileFinding};
use fallow_types::results::{AnalysisResults, UnresolvedImport, UnusedFile};
use std::path::PathBuf;

let mut results = AnalysisResults::default();
results
    .unused_files
    .push(UnusedFileFinding::with_actions(UnusedFile {
        path: PathBuf::from("a.ts"),
    }));
results
    .unresolved_imports
    .push(UnresolvedImportFinding::with_actions(UnresolvedImport {
        path: PathBuf::from("b.ts"),
        specifier: "./missing".to_string(),
        line: 1,
        col: 0,
        specifier_col: 0,
    }));
assert_eq!(results.total_issues(), 2);

pub const fn has_issues(&self) -> bool

Whether any issues were found.

pub fn merge_into(&mut self, other: Self)

Merge other into self, taking the union of every field.

This is the single canonical way to combine two AnalysisResults (the LSP merges per-project-root results through it). The method exhaustively destructures Self, so adding a field to the struct becomes a compile error here instead of a silently-dropped field. See issue #444.

Every Vec field is appended (callers dedup downstream where needed, e.g. the LSP’s identity-keyed dedup_results). suppression_count sums; entry_point_summary keeps self’s value when present and otherwise adopts other’s.

pub fn sort(&mut self)

Sort all result arrays for deterministic output ordering.

Parallel collection (rayon, FxHashMap iteration) does not guarantee insertion order, so the same project can produce different orderings across runs. This method canonicalises every result list by sorting on (path, line, col, name) so that JSON/SARIF/human output is stable.

Trait Implementations

impl Clone for AnalysisResults

fn clone(&self) -> AnalysisResults

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AnalysisResults

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AnalysisResults

fn default() -> AnalysisResults

Returns the “default value” for a type.

impl Serialize for AnalysisResults

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.