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 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 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 suppression_count: usize,
    pub feature_flags: Vec<FeatureFlag>,
    pub export_usages: Vec<ExportUsage>,
    pub entry_point_summary: Option<EntryPointSummary>,
}

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.

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.

stale_suppressions: Vec<StaleSuppression>

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

unused_catalog_entries: Vec<UnusedCatalogEntryFinding>

Entries in pnpm-workspace.yaml’s catalog: or catalogs: sections not referenced by any workspace package via the catalog: protocol. Wrapped in UnusedCatalogEntryFinding so each entry carries a typed actions array natively, with per-instance auto_fixable derived from hardcoded_consumers.

empty_catalog_groups: Vec<EmptyCatalogGroupFinding>

Named groups under pnpm-workspace.yaml’s catalogs: section 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. pnpm 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.

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.

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.

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.

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 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.