fallow-engine 3.5.1

Typed analysis engine facade for fallow consumers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Health pipeline carrier types shared by the engine health executor.

use fallow_config::{ResolvedConfig, WorkspaceInfo};
use fallow_output::DiffIndex;
use fallow_types::workspace::WorkspaceDiagnostic;
use rustc_hash::{FxHashMap, FxHashSet};
use std::path::PathBuf;

use crate::{
    duplicates::DuplicationReport,
    results::{AnalysisResults, DeadCodeAnalysisArtifacts},
};

use super::StylingAnalysisArtifacts;

/// Discovery / parse inputs the CLI resolves before calling the engine.
pub struct HealthPipelineInputs {
    pub config: ResolvedConfig,
    pub files: Vec<fallow_types::discover::DiscoveredFile>,
    pub modules: Vec<fallow_types::extract::ModuleInfo>,
    /// Pre-parse pipeline timings (config / discover / parse milliseconds).
    pub config_ms: f64,
    pub discover_ms: f64,
    pub parse_ms: f64,
    pub parse_cpu_ms: f64,
    /// True when discover + parse were reused from the upstream check pass.
    pub shared_parse: bool,
    pub pre_computed_analysis: Option<DeadCodeAnalysisArtifacts>,
    pub dead_code_results: Option<AnalysisResults>,
    pub styling_artifacts: Option<StylingAnalysisArtifacts>,
    pub pre_computed_duplication: Option<DuplicationReport>,
    pub workspaces: Vec<WorkspaceInfo>,
    pub workspace_diagnostics: Vec<WorkspaceDiagnostic>,
}

pub(super) struct HealthPipelineRunInputs<M> {
    pub(super) config: ResolvedConfig,
    pub(super) files: Vec<fallow_types::discover::DiscoveredFile>,
    pub(super) modules: M,
    pub(super) config_ms: f64,
    pub(super) discover_ms: f64,
    pub(super) parse_ms: f64,
    pub(super) parse_cpu_ms: f64,
    pub(super) shared_parse: bool,
    pub(super) pre_computed_analysis: Option<DeadCodeAnalysisArtifacts>,
    pub(super) dead_code_results: Option<AnalysisResults>,
    pub(super) styling_artifacts: Option<StylingAnalysisArtifacts>,
    pub(super) pre_computed_duplication: Option<DuplicationReport>,
    pub(super) workspaces: Vec<WorkspaceInfo>,
    pub(super) workspace_diagnostics: Vec<WorkspaceDiagnostic>,
}

impl From<HealthPipelineInputs>
    for HealthPipelineRunInputs<Vec<fallow_types::extract::ModuleInfo>>
{
    fn from(input: HealthPipelineInputs) -> Self {
        Self {
            config: input.config,
            files: input.files,
            modules: input.modules,
            config_ms: input.config_ms,
            discover_ms: input.discover_ms,
            parse_ms: input.parse_ms,
            parse_cpu_ms: input.parse_cpu_ms,
            shared_parse: input.shared_parse,
            pre_computed_analysis: input.pre_computed_analysis,
            dead_code_results: input.dead_code_results,
            styling_artifacts: input.styling_artifacts,
            pre_computed_duplication: input.pre_computed_duplication,
            workspaces: input.workspaces,
            workspace_diagnostics: input.workspace_diagnostics,
        }
    }
}

/// Scope inputs the CLI resolves before calling the engine.
///
/// The engine no longer fetches changed files, workspace roots, the shared diff
/// index, or the CODEOWNERS-backed grouping resolver itself: those touch CLI
/// state (the shared-diff `OnceLock`, CODEOWNERS parsing, workspace discovery
/// error rendering), so the CLI resolves them and threads them in here.
pub struct HealthScopeInputs<'a, R> {
    pub changed_files: Option<FxHashSet<PathBuf>>,
    pub diff_index: Option<&'a DiffIndex>,
    pub ws_roots: Option<Vec<PathBuf>>,
    pub group_resolver: Option<R>,
}

pub(super) struct HealthPipelineTimings {
    pub(super) config: f64,
    pub(super) discover: f64,
    pub(super) parse: f64,
    /// Summed parse CPU time across rayon workers; `0.0` when parse was reused.
    pub(super) parse_cpu: f64,
    /// True when discover + parse were reused from the upstream check pass.
    pub(super) shared_parse: bool,
}

impl HealthPipelineTimings {
    pub(super) fn into_base_input(self, complexity_ms: f64) -> HealthTimingBaseInput {
        HealthTimingBaseInput {
            config_ms: self.config,
            discover_ms: self.discover,
            parse_ms: self.parse,
            parse_cpu_ms: self.parse_cpu,
            complexity_ms,
            shared_parse: self.shared_parse,
        }
    }
}

pub(super) struct HealthScope<'a, R> {
    pub(super) max_cyclomatic: u16,
    pub(super) max_cognitive: u16,
    pub(super) max_crap: f64,
    pub(super) enforce_crap: bool,
    pub(super) ignore_set: globset::GlobSet,
    pub(super) changed_files: Option<FxHashSet<PathBuf>>,
    pub(super) diff_index: Option<&'a DiffIndex>,
    pub(super) ws_roots: Option<Vec<PathBuf>>,
    pub(super) group_resolver: Option<R>,
    pub(super) file_paths: FxHashMap<crate::discover::FileId, &'a PathBuf>,
}

pub(super) struct HealthTimingBaseInput {
    pub(super) config_ms: f64,
    pub(super) discover_ms: f64,
    pub(super) parse_ms: f64,
    pub(super) parse_cpu_ms: f64,
    pub(super) complexity_ms: f64,
    pub(super) shared_parse: bool,
}