Struct AnalysisResults 

pub struct AnalysisResults {

    pub unused_files: Vec<UnusedFile>,
    pub unused_exports: Vec<UnusedExport>,
    pub unused_types: Vec<UnusedExport>,
    pub unused_dependencies: Vec<UnusedDependency>,
    pub unused_dev_dependencies: Vec<UnusedDependency>,
    pub unused_optional_dependencies: Vec<UnusedDependency>,
    pub unused_enum_members: Vec<UnusedMember>,
    pub unused_class_members: Vec<UnusedMember>,
    pub unresolved_imports: Vec<UnresolvedImport>,
    pub unlisted_dependencies: Vec<UnlistedDependency>,
    pub duplicate_exports: Vec<DuplicateExport>,
    pub type_only_dependencies: Vec<TypeOnlyDependency>,
    pub test_only_dependencies: Vec<TestOnlyDependency>,
    pub circular_dependencies: Vec<CircularDependency>,
    pub boundary_violations: Vec<BoundaryViolation>,
    pub feature_flags: Vec<FeatureFlag>,
    pub export_usages: Vec<ExportUsage>,
    pub entry_point_summary: Option<EntryPointSummary>,
}

Complete analysis results.

Examples

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(UnusedFile {
    path: PathBuf::from("src/dead.ts"),
});
assert_eq!(results.total_issues(), 1);
assert!(results.has_issues());

Fields

unused_files: Vec<UnusedFile>

Files not reachable from any entry point.

unused_exports: Vec<UnusedExport>

Exports never imported by other modules.

unused_types: Vec<UnusedExport>

Type exports never imported by other modules.

unused_dependencies: Vec<UnusedDependency>

Dependencies listed in package.json but never imported.

unused_dev_dependencies: Vec<UnusedDependency>

Dev dependencies listed in package.json but never imported.

unused_optional_dependencies: Vec<UnusedDependency>

Optional dependencies listed in package.json but never imported.

unused_enum_members: Vec<UnusedMember>

Enum members never accessed.

unused_class_members: Vec<UnusedMember>

Class members never accessed.

unresolved_imports: Vec<UnresolvedImport>

Import specifiers that could not be resolved.

unlisted_dependencies: Vec<UnlistedDependency>

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

duplicate_exports: Vec<DuplicateExport>

Exports with the same name across multiple modules.

type_only_dependencies: Vec<TypeOnlyDependency>

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

test_only_dependencies: Vec<TestOnlyDependency>

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

circular_dependencies: Vec<CircularDependency>

Circular dependency chains detected in the module graph.

boundary_violations: Vec<BoundaryViolation>

Imports that cross architecture boundary rules.

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::results::{AnalysisResults, UnusedFile, UnresolvedImport};
use std::path::PathBuf;

let mut results = AnalysisResults::default();
results.unused_files.push(UnusedFile { path: PathBuf::from("a.ts") });
results.unresolved_imports.push(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.