fallow_types/
suppress.rs

1//! Inline suppression comment types and issue kind definitions.
2
3/// Issue kind for suppression matching.
4///
5/// # Examples
6///
7/// ```
8/// use fallow_types::suppress::IssueKind;
9///
10/// let kind = IssueKind::parse("unused-export");
11/// assert_eq!(kind, Some(IssueKind::UnusedExport));
12///
13/// // Round-trip through discriminant
14/// let d = IssueKind::UnusedFile.to_discriminant();
15/// assert_eq!(IssueKind::from_discriminant(d), Some(IssueKind::UnusedFile));
16///
17/// // Unknown strings return None
18/// assert_eq!(IssueKind::parse("not-a-kind"), None);
19/// ```
20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
21pub enum IssueKind {
22    /// An unused file.
23    UnusedFile,
24    /// An unused export.
25    UnusedExport,
26    /// An unused type export.
27    UnusedType,
28    /// An exported signature that references a same-file private type.
29    PrivateTypeLeak,
30    /// An unused dependency.
31    UnusedDependency,
32    /// An unused dev dependency.
33    UnusedDevDependency,
34    /// An unused enum member.
35    UnusedEnumMember,
36    /// An unused class member.
37    UnusedClassMember,
38    /// An unresolved import.
39    UnresolvedImport,
40    /// An unlisted dependency.
41    UnlistedDependency,
42    /// A duplicate export name across modules.
43    DuplicateExport,
44    /// Code duplication.
45    CodeDuplication,
46    /// A circular dependency chain.
47    CircularDependency,
48    /// A cycle or self-loop in the re-export edge subgraph (barrel files
49    /// re-exporting from each other in a loop). Structurally always a bug:
50    /// chain propagation through the cycle is a no-op.
51    ReExportCycle,
52    /// A production dependency only imported via type-only imports.
53    TypeOnlyDependency,
54    /// A production dependency only imported by test files.
55    TestOnlyDependency,
56    /// An import that crosses an architecture boundary.
57    BoundaryViolation,
58    /// A runtime file or export with no test dependency path.
59    CoverageGaps,
60    /// A detected feature flag pattern.
61    FeatureFlag,
62    /// A function exceeding complexity thresholds (health command).
63    Complexity,
64    /// A suppression comment or JSDoc tag that no longer matches any issue.
65    StaleSuppression,
66    /// A pnpm catalog entry in pnpm-workspace.yaml not referenced by any workspace package.
67    PnpmCatalogEntry,
68    /// A named pnpm catalog group in pnpm-workspace.yaml with no entries.
69    EmptyCatalogGroup,
70    /// A workspace package.json reference (`catalog:` / `catalog:<name>`) pointing at
71    /// a catalog that does not declare the consumed package.
72    UnresolvedCatalogReference,
73    /// An entry in pnpm's `overrides:` / `pnpm.overrides` whose target package
74    /// is not declared in any workspace `package.json`.
75    UnusedDependencyOverride,
76    /// An entry in pnpm's `overrides:` / `pnpm.overrides` whose key or value
77    /// cannot be parsed into a valid pnpm shape.
78    MisconfiguredDependencyOverride,
79    /// A `"use client"` file that transitively imports a module reading a
80    /// non-public `process.env` secret (security candidate).
81    SecurityClientServerLeak,
82    /// A syntactic tainted-sink candidate matched against the data-driven
83    /// security matcher catalogue (`security_matchers.toml`). ONE suppression
84    /// token covers all catalogue categories.
85    SecuritySink,
86    /// A banned call or banned import matched by a declarative rule pack
87    /// (`rulePacks` config). ONE suppression token covers every pack rule;
88    /// per-rule suppression is a tracked follow-up.
89    PolicyViolation,
90}
91
92impl IssueKind {
93    /// Parse an issue kind from the string tokens used in CLI output and suppression comments.
94    #[must_use]
95    pub fn parse(s: &str) -> Option<Self> {
96        match s {
97            "unused-file" => Some(Self::UnusedFile),
98            "unused-export" => Some(Self::UnusedExport),
99            "unused-type" => Some(Self::UnusedType),
100            "private-type-leak" => Some(Self::PrivateTypeLeak),
101            "unused-dependency" => Some(Self::UnusedDependency),
102            "unused-dev-dependency" => Some(Self::UnusedDevDependency),
103            "unused-enum-member" => Some(Self::UnusedEnumMember),
104            "unused-class-member" => Some(Self::UnusedClassMember),
105            "unresolved-import" => Some(Self::UnresolvedImport),
106            "unlisted-dependency" => Some(Self::UnlistedDependency),
107            "duplicate-export" => Some(Self::DuplicateExport),
108            "code-duplication" => Some(Self::CodeDuplication),
109            "circular-dependency" | "circular-dependencies" => Some(Self::CircularDependency),
110            "re-export-cycle" | "re-export-cycles" | "reexport-cycle" | "reexport-cycles" => {
111                Some(Self::ReExportCycle)
112            }
113            "type-only-dependency" => Some(Self::TypeOnlyDependency),
114            "test-only-dependency" => Some(Self::TestOnlyDependency),
115            "boundary-violation" | "boundary-call-violation" | "boundary-call-violations" => {
116                Some(Self::BoundaryViolation)
117            }
118            "coverage-gaps" => Some(Self::CoverageGaps),
119            "feature-flag" => Some(Self::FeatureFlag),
120            "complexity" => Some(Self::Complexity),
121            "stale-suppression" => Some(Self::StaleSuppression),
122            "unused-catalog-entry" | "unused-catalog-entries" => Some(Self::PnpmCatalogEntry),
123            "empty-catalog-group" | "empty-catalog-groups" => Some(Self::EmptyCatalogGroup),
124            "unresolved-catalog-reference" | "unresolved-catalog-references" => {
125                Some(Self::UnresolvedCatalogReference)
126            }
127            "unused-dependency-override" | "unused-dependency-overrides" => {
128                Some(Self::UnusedDependencyOverride)
129            }
130            "misconfigured-dependency-override" | "misconfigured-dependency-overrides" => {
131                Some(Self::MisconfiguredDependencyOverride)
132            }
133            "security-client-server-leak" => Some(Self::SecurityClientServerLeak),
134            "security-sink" => Some(Self::SecuritySink),
135            "policy-violation" | "policy-violations" => Some(Self::PolicyViolation),
136            _ => None,
137        }
138    }
139
140    /// Convert to a u8 discriminant for compact cache storage.
141    #[must_use]
142    pub const fn to_discriminant(self) -> u8 {
143        match self {
144            Self::UnusedFile => 1,
145            Self::UnusedExport => 2,
146            Self::UnusedType => 3,
147            Self::PrivateTypeLeak => 4,
148            Self::UnusedDependency => 5,
149            Self::UnusedDevDependency => 6,
150            Self::UnusedEnumMember => 7,
151            Self::UnusedClassMember => 8,
152            Self::UnresolvedImport => 9,
153            Self::UnlistedDependency => 10,
154            Self::DuplicateExport => 11,
155            Self::CodeDuplication => 12,
156            Self::CircularDependency => 13,
157            Self::TypeOnlyDependency => 14,
158            Self::TestOnlyDependency => 15,
159            Self::BoundaryViolation => 16,
160            Self::CoverageGaps => 17,
161            Self::FeatureFlag => 18,
162            Self::Complexity => 19,
163            Self::StaleSuppression => 20,
164            Self::PnpmCatalogEntry => 21,
165            Self::UnresolvedCatalogReference => 22,
166            Self::UnusedDependencyOverride => 23,
167            Self::MisconfiguredDependencyOverride => 24,
168            Self::EmptyCatalogGroup => 25,
169            Self::ReExportCycle => 26,
170            Self::SecurityClientServerLeak => 27,
171            Self::SecuritySink => 28,
172            Self::PolicyViolation => 29,
173        }
174    }
175
176    /// Reconstruct from a cache discriminant.
177    #[must_use]
178    pub const fn from_discriminant(d: u8) -> Option<Self> {
179        match d {
180            1 => Some(Self::UnusedFile),
181            2 => Some(Self::UnusedExport),
182            3 => Some(Self::UnusedType),
183            4 => Some(Self::PrivateTypeLeak),
184            5 => Some(Self::UnusedDependency),
185            6 => Some(Self::UnusedDevDependency),
186            7 => Some(Self::UnusedEnumMember),
187            8 => Some(Self::UnusedClassMember),
188            9 => Some(Self::UnresolvedImport),
189            10 => Some(Self::UnlistedDependency),
190            11 => Some(Self::DuplicateExport),
191            12 => Some(Self::CodeDuplication),
192            13 => Some(Self::CircularDependency),
193            14 => Some(Self::TypeOnlyDependency),
194            15 => Some(Self::TestOnlyDependency),
195            16 => Some(Self::BoundaryViolation),
196            17 => Some(Self::CoverageGaps),
197            18 => Some(Self::FeatureFlag),
198            19 => Some(Self::Complexity),
199            20 => Some(Self::StaleSuppression),
200            21 => Some(Self::PnpmCatalogEntry),
201            22 => Some(Self::UnresolvedCatalogReference),
202            23 => Some(Self::UnusedDependencyOverride),
203            24 => Some(Self::MisconfiguredDependencyOverride),
204            25 => Some(Self::EmptyCatalogGroup),
205            26 => Some(Self::ReExportCycle),
206            27 => Some(Self::SecurityClientServerLeak),
207            28 => Some(Self::SecuritySink),
208            29 => Some(Self::PolicyViolation),
209            _ => None,
210        }
211    }
212}
213
214/// A suppression directive parsed from a source comment.
215///
216/// # Examples
217///
218/// ```
219/// use fallow_types::suppress::{Suppression, IssueKind};
220///
221/// // File-wide suppression (line 0, no specific kind)
222/// let file_wide = Suppression { line: 0, comment_line: 1, kind: None };
223/// assert_eq!(file_wide.line, 0);
224///
225/// // Line-specific suppression for unused exports
226/// let line_suppress = Suppression {
227///     line: 42,
228///     comment_line: 41,
229///     kind: Some(IssueKind::UnusedExport),
230/// };
231/// assert_eq!(line_suppress.kind, Some(IssueKind::UnusedExport));
232/// ```
233#[derive(Debug, Clone)]
234pub struct Suppression {
235    /// 1-based line this suppression applies to. 0 = file-wide suppression.
236    pub line: u32,
237    /// 1-based line where the suppression comment itself appears.
238    /// For `fallow-ignore-next-line`, this is `line - 1`.
239    /// For `fallow-ignore-file`, this is the actual line of the comment in the source.
240    pub comment_line: u32,
241    /// None = suppress all issue kinds on this line.
242    pub kind: Option<IssueKind>,
243}
244
245/// A suppression token that did not parse to any known `IssueKind`.
246///
247/// Emitted alongside `Suppression` when a `// fallow-ignore-*` marker contains
248/// a typo or an obsolete issue-kind name. The known tokens on the same marker
249/// are recorded as normal `Suppression` entries; this struct preserves the
250/// unknown token so the downstream `find_stale` pass can surface it as a
251/// `StaleSuppression` finding with `kind_known: false`. Without this, the
252/// entire suppression line would be discarded silently. See issue #449.
253#[derive(Debug, Clone)]
254pub struct UnknownSuppressionKind {
255    /// 1-based line where the suppression comment itself appears.
256    pub comment_line: u32,
257    /// Whether the marker was `fallow-ignore-file` (`true`) or
258    /// `fallow-ignore-next-line` (`false`).
259    pub is_file_level: bool,
260    /// The verbatim token from the marker that did not parse.
261    pub token: String,
262}
263
264/// Canonical kebab-case names accepted by `IssueKind::parse`, including
265/// documented plural aliases.
266///
267/// Used by `closest_known_kind_name` for Levenshtein "did you mean?" hints
268/// when a suppression marker carries an unknown token. Keep in sync with the
269/// `IssueKind::parse` match table above; the
270/// `issue_kind_parse_covers_known_names` test asserts every entry round-trips.
271pub const KNOWN_ISSUE_KIND_NAMES: &[&str] = &[
272    "unused-file",
273    "unused-export",
274    "unused-type",
275    "private-type-leak",
276    "unused-dependency",
277    "unused-dev-dependency",
278    "unused-enum-member",
279    "unused-class-member",
280    "unresolved-import",
281    "unlisted-dependency",
282    "duplicate-export",
283    "code-duplication",
284    "circular-dependency",
285    "circular-dependencies",
286    "re-export-cycle",
287    "re-export-cycles",
288    "reexport-cycle",
289    "reexport-cycles",
290    "type-only-dependency",
291    "test-only-dependency",
292    "boundary-violation",
293    "boundary-call-violation",
294    "boundary-call-violations",
295    "coverage-gaps",
296    "feature-flag",
297    "complexity",
298    "stale-suppression",
299    "unused-catalog-entry",
300    "unused-catalog-entries",
301    "empty-catalog-group",
302    "empty-catalog-groups",
303    "unresolved-catalog-reference",
304    "unresolved-catalog-references",
305    "unused-dependency-override",
306    "unused-dependency-overrides",
307    "misconfigured-dependency-override",
308    "misconfigured-dependency-overrides",
309    "security-client-server-leak",
310    "security-sink",
311    "policy-violation",
312    "policy-violations",
313];
314
315/// Levenshtein edit distance between two ASCII-leaning strings.
316///
317/// Local duplicate of the config-crate helper (see
318/// `crates/config/src/config/rules.rs::levenshtein`) so `fallow-types` can
319/// compute "did you mean?" suggestions for unknown suppression tokens without
320/// taking a dependency on `fallow-config`. Issue-kind names are short
321/// (max ~33 chars) so allocation cost is negligible.
322fn levenshtein(a: &str, b: &str) -> usize {
323    let a_bytes = a.as_bytes();
324    let b_bytes = b.as_bytes();
325    let (a_len, b_len) = (a_bytes.len(), b_bytes.len());
326
327    if a_len == 0 {
328        return b_len;
329    }
330    if b_len == 0 {
331        return a_len;
332    }
333
334    let mut prev: Vec<usize> = (0..=b_len).collect();
335    let mut curr: Vec<usize> = vec![0; b_len + 1];
336
337    for i in 1..=a_len {
338        curr[0] = i;
339        for j in 1..=b_len {
340            let cost = usize::from(a_bytes[i - 1] != b_bytes[j - 1]);
341            curr[j] = (prev[j] + 1).min(curr[j - 1] + 1).min(prev[j - 1] + cost);
342        }
343        std::mem::swap(&mut prev, &mut curr);
344    }
345
346    prev[b_len]
347}
348
349/// Find the closest known issue-kind name to `input` when it is plausibly a typo.
350///
351/// Returns the best match when the Levenshtein distance is at most 2 AND
352/// the input is long enough that the match is not coincidental
353/// (`input.len() / 2 > distance`). Returns `None` for completely novel
354/// strings where a suggestion would be misleading.
355#[must_use]
356pub fn closest_known_kind_name(input: &str) -> Option<&'static str> {
357    let input_lower = input.to_ascii_lowercase();
358    let mut best: Option<(&'static str, usize)> = None;
359
360    for &candidate in KNOWN_ISSUE_KIND_NAMES {
361        let d = levenshtein(&input_lower, candidate);
362        if best.is_none_or(|(_, b_dist)| d < b_dist) {
363            best = Some((candidate, d));
364        }
365    }
366
367    best.filter(|&(_, d)| d > 0 && d <= 2 && input_lower.len() / 2 > d)
368        .map(|(name, _)| name)
369}
370
371const _: () = assert!(std::mem::size_of::<Suppression>() == 12);
372const _: () = assert!(std::mem::size_of::<IssueKind>() == 1);
373
374#[cfg(test)]
375mod tests {
376    use super::*;
377
378    #[test]
379    fn issue_kind_from_str_all_variants() {
380        assert_eq!(IssueKind::parse("unused-file"), Some(IssueKind::UnusedFile));
381        assert_eq!(
382            IssueKind::parse("unused-export"),
383            Some(IssueKind::UnusedExport)
384        );
385        assert_eq!(IssueKind::parse("unused-type"), Some(IssueKind::UnusedType));
386        assert_eq!(
387            IssueKind::parse("private-type-leak"),
388            Some(IssueKind::PrivateTypeLeak)
389        );
390        assert_eq!(
391            IssueKind::parse("unused-dependency"),
392            Some(IssueKind::UnusedDependency)
393        );
394        assert_eq!(
395            IssueKind::parse("unused-dev-dependency"),
396            Some(IssueKind::UnusedDevDependency)
397        );
398        assert_eq!(
399            IssueKind::parse("unused-enum-member"),
400            Some(IssueKind::UnusedEnumMember)
401        );
402        assert_eq!(
403            IssueKind::parse("unused-class-member"),
404            Some(IssueKind::UnusedClassMember)
405        );
406        assert_eq!(
407            IssueKind::parse("unresolved-import"),
408            Some(IssueKind::UnresolvedImport)
409        );
410        assert_eq!(
411            IssueKind::parse("unlisted-dependency"),
412            Some(IssueKind::UnlistedDependency)
413        );
414        assert_eq!(
415            IssueKind::parse("duplicate-export"),
416            Some(IssueKind::DuplicateExport)
417        );
418        assert_eq!(
419            IssueKind::parse("code-duplication"),
420            Some(IssueKind::CodeDuplication)
421        );
422        assert_eq!(
423            IssueKind::parse("circular-dependency"),
424            Some(IssueKind::CircularDependency)
425        );
426        assert_eq!(
427            IssueKind::parse("circular-dependencies"),
428            Some(IssueKind::CircularDependency)
429        );
430        assert_eq!(
431            IssueKind::parse("type-only-dependency"),
432            Some(IssueKind::TypeOnlyDependency)
433        );
434        assert_eq!(
435            IssueKind::parse("test-only-dependency"),
436            Some(IssueKind::TestOnlyDependency)
437        );
438        assert_eq!(
439            IssueKind::parse("boundary-violation"),
440            Some(IssueKind::BoundaryViolation)
441        );
442        // The boundary family token also accepts the rule-id-shaped alias so
443        // users who derive the token from the `boundary-call-violation` rule
444        // id by analogy get a working suppression instead of a silent no-op.
445        assert_eq!(
446            IssueKind::parse("boundary-call-violation"),
447            Some(IssueKind::BoundaryViolation)
448        );
449        assert_eq!(
450            IssueKind::parse("boundary-call-violations"),
451            Some(IssueKind::BoundaryViolation)
452        );
453        assert_eq!(
454            IssueKind::parse("coverage-gaps"),
455            Some(IssueKind::CoverageGaps)
456        );
457        assert_eq!(
458            IssueKind::parse("feature-flag"),
459            Some(IssueKind::FeatureFlag)
460        );
461        assert_eq!(IssueKind::parse("complexity"), Some(IssueKind::Complexity));
462        assert_eq!(
463            IssueKind::parse("stale-suppression"),
464            Some(IssueKind::StaleSuppression)
465        );
466        assert_eq!(
467            IssueKind::parse("unused-catalog-entry"),
468            Some(IssueKind::PnpmCatalogEntry)
469        );
470        assert_eq!(
471            IssueKind::parse("unused-catalog-entries"),
472            Some(IssueKind::PnpmCatalogEntry)
473        );
474        assert_eq!(
475            IssueKind::parse("empty-catalog-group"),
476            Some(IssueKind::EmptyCatalogGroup)
477        );
478        assert_eq!(
479            IssueKind::parse("empty-catalog-groups"),
480            Some(IssueKind::EmptyCatalogGroup)
481        );
482        assert_eq!(
483            IssueKind::parse("unresolved-catalog-reference"),
484            Some(IssueKind::UnresolvedCatalogReference)
485        );
486        assert_eq!(
487            IssueKind::parse("unresolved-catalog-references"),
488            Some(IssueKind::UnresolvedCatalogReference)
489        );
490        assert_eq!(
491            IssueKind::parse("unused-dependency-override"),
492            Some(IssueKind::UnusedDependencyOverride)
493        );
494        assert_eq!(
495            IssueKind::parse("unused-dependency-overrides"),
496            Some(IssueKind::UnusedDependencyOverride)
497        );
498        assert_eq!(
499            IssueKind::parse("misconfigured-dependency-override"),
500            Some(IssueKind::MisconfiguredDependencyOverride)
501        );
502        assert_eq!(
503            IssueKind::parse("misconfigured-dependency-overrides"),
504            Some(IssueKind::MisconfiguredDependencyOverride)
505        );
506        assert_eq!(
507            IssueKind::parse("security-client-server-leak"),
508            Some(IssueKind::SecurityClientServerLeak)
509        );
510        assert_eq!(
511            IssueKind::parse("security-sink"),
512            Some(IssueKind::SecuritySink)
513        );
514        assert_eq!(
515            IssueKind::parse("policy-violation"),
516            Some(IssueKind::PolicyViolation)
517        );
518        assert_eq!(
519            IssueKind::parse("policy-violations"),
520            Some(IssueKind::PolicyViolation)
521        );
522    }
523
524    #[test]
525    fn issue_kind_from_str_unknown() {
526        assert_eq!(IssueKind::parse("foo"), None);
527        assert_eq!(IssueKind::parse(""), None);
528    }
529
530    #[test]
531    fn issue_kind_from_str_near_misses() {
532        assert_eq!(IssueKind::parse("Unused-File"), None);
533        assert_eq!(IssueKind::parse("UNUSED-EXPORT"), None);
534        assert_eq!(IssueKind::parse("unused_file"), None);
535        assert_eq!(IssueKind::parse("unused-files"), None);
536    }
537
538    #[test]
539    fn discriminant_out_of_range() {
540        assert_eq!(IssueKind::from_discriminant(0), None);
541        assert_eq!(
542            IssueKind::from_discriminant(29),
543            Some(IssueKind::PolicyViolation)
544        );
545        assert_eq!(IssueKind::from_discriminant(30), None);
546        assert_eq!(IssueKind::from_discriminant(u8::MAX), None);
547    }
548
549    #[test]
550    fn discriminant_roundtrip() {
551        for kind in [
552            IssueKind::UnusedFile,
553            IssueKind::UnusedExport,
554            IssueKind::UnusedType,
555            IssueKind::PrivateTypeLeak,
556            IssueKind::UnusedDependency,
557            IssueKind::UnusedDevDependency,
558            IssueKind::UnusedEnumMember,
559            IssueKind::UnusedClassMember,
560            IssueKind::UnresolvedImport,
561            IssueKind::UnlistedDependency,
562            IssueKind::DuplicateExport,
563            IssueKind::CodeDuplication,
564            IssueKind::CircularDependency,
565            IssueKind::ReExportCycle,
566            IssueKind::TypeOnlyDependency,
567            IssueKind::TestOnlyDependency,
568            IssueKind::BoundaryViolation,
569            IssueKind::CoverageGaps,
570            IssueKind::FeatureFlag,
571            IssueKind::Complexity,
572            IssueKind::StaleSuppression,
573            IssueKind::PnpmCatalogEntry,
574            IssueKind::EmptyCatalogGroup,
575            IssueKind::UnresolvedCatalogReference,
576            IssueKind::UnusedDependencyOverride,
577            IssueKind::MisconfiguredDependencyOverride,
578            IssueKind::SecurityClientServerLeak,
579            IssueKind::SecuritySink,
580            IssueKind::PolicyViolation,
581        ] {
582            assert_eq!(
583                IssueKind::from_discriminant(kind.to_discriminant()),
584                Some(kind)
585            );
586        }
587        assert_eq!(IssueKind::from_discriminant(0), None);
588        assert_eq!(IssueKind::from_discriminant(30), None);
589    }
590
591    #[test]
592    fn discriminant_values_are_unique() {
593        let all_kinds = [
594            IssueKind::UnusedFile,
595            IssueKind::UnusedExport,
596            IssueKind::UnusedType,
597            IssueKind::PrivateTypeLeak,
598            IssueKind::UnusedDependency,
599            IssueKind::UnusedDevDependency,
600            IssueKind::UnusedEnumMember,
601            IssueKind::UnusedClassMember,
602            IssueKind::UnresolvedImport,
603            IssueKind::UnlistedDependency,
604            IssueKind::DuplicateExport,
605            IssueKind::CodeDuplication,
606            IssueKind::CircularDependency,
607            IssueKind::ReExportCycle,
608            IssueKind::TypeOnlyDependency,
609            IssueKind::TestOnlyDependency,
610            IssueKind::BoundaryViolation,
611            IssueKind::CoverageGaps,
612            IssueKind::FeatureFlag,
613            IssueKind::Complexity,
614            IssueKind::StaleSuppression,
615            IssueKind::PnpmCatalogEntry,
616            IssueKind::EmptyCatalogGroup,
617            IssueKind::UnresolvedCatalogReference,
618            IssueKind::UnusedDependencyOverride,
619            IssueKind::MisconfiguredDependencyOverride,
620            IssueKind::SecurityClientServerLeak,
621            IssueKind::SecuritySink,
622            IssueKind::PolicyViolation,
623        ];
624        let discriminants: Vec<u8> = all_kinds.iter().map(|k| k.to_discriminant()).collect();
625        let mut sorted = discriminants.clone();
626        sorted.sort_unstable();
627        sorted.dedup();
628        assert_eq!(
629            discriminants.len(),
630            sorted.len(),
631            "discriminant values must be unique"
632        );
633    }
634
635    #[test]
636    fn discriminant_starts_at_one() {
637        assert_eq!(IssueKind::UnusedFile.to_discriminant(), 1);
638    }
639
640    #[test]
641    fn suppression_line_zero_is_file_wide() {
642        let s = Suppression {
643            line: 0,
644            comment_line: 1,
645            kind: None,
646        };
647        assert_eq!(s.line, 0);
648        assert!(s.kind.is_none());
649    }
650
651    #[test]
652    fn suppression_with_specific_kind_and_line() {
653        let s = Suppression {
654            line: 42,
655            comment_line: 41,
656            kind: Some(IssueKind::UnusedExport),
657        };
658        assert_eq!(s.line, 42);
659        assert_eq!(s.comment_line, 41);
660        assert_eq!(s.kind, Some(IssueKind::UnusedExport));
661    }
662
663    #[test]
664    fn known_issue_kind_names_parses_each_entry() {
665        for &name in KNOWN_ISSUE_KIND_NAMES {
666            assert!(
667                IssueKind::parse(name).is_some(),
668                "KNOWN_ISSUE_KIND_NAMES contains '{name}' but IssueKind::parse rejects it"
669            );
670        }
671    }
672
673    #[test]
674    fn closest_known_kind_name_finds_near_misses() {
675        assert_eq!(
676            closest_known_kind_name("unused-exports"),
677            Some("unused-export")
678        );
679        assert_eq!(closest_known_kind_name("unused-files"), Some("unused-file"));
680        assert_eq!(closest_known_kind_name("complxity"), Some("complexity"));
681    }
682
683    #[test]
684    fn closest_known_kind_name_rejects_novel_strings() {
685        assert_eq!(closest_known_kind_name("xyzzy"), None);
686        assert_eq!(closest_known_kind_name("foo"), None);
687        assert_eq!(closest_known_kind_name(""), None);
688    }
689
690    #[test]
691    fn closest_known_kind_name_skips_exact_match() {
692        assert_eq!(closest_known_kind_name("unused-export"), None);
693    }
694}
fallow_types/suppress.rs

fallow_types/
suppress.rs
