Enum IssueKind 

pub enum IssueKind {
    UnusedFile,
    UnusedExport,
    UnusedType,
    PrivateTypeLeak,
    UnusedDependency,
    UnusedDevDependency,
    UnusedEnumMember,
    UnusedClassMember,
    UnresolvedImport,
    UnlistedDependency,
    DuplicateExport,
    CodeDuplication,
    CircularDependency,
    ReExportCycle,
    TypeOnlyDependency,
    TestOnlyDependency,
    BoundaryViolation,
    CoverageGaps,
    FeatureFlag,
    Complexity,
    StaleSuppression,
    PnpmCatalogEntry,
    EmptyCatalogGroup,
    UnresolvedCatalogReference,
    UnusedDependencyOverride,
    MisconfiguredDependencyOverride,
    SecurityClientServerLeak,
    SecuritySink,
    PolicyViolation,
    InvalidClientExport,
    MixedClientServerBarrel,
    MisplacedDirective,
    UnusedStoreMember,
    UnprovidedInject,
    RouteCollision,
    DynamicSegmentNameConflict,
    UnrenderedComponent,
    UnusedComponentProp,
    UnusedComponentEmit,
    UnusedComponentInput,
    UnusedComponentOutput,
    UnusedServerAction,
    UnusedLoadDataKey,
    PropDrilling,
    ThinWrapper,
    DuplicatePropShape,
    UnusedSvelteEvent,
}

Issue kind for suppression matching.

Examples

use fallow_types::suppress::IssueKind;

let kind = IssueKind::parse("unused-export");
assert_eq!(kind, Some(IssueKind::UnusedExport));

// Round-trip through discriminant
let d = IssueKind::UnusedFile.to_discriminant();
assert_eq!(IssueKind::from_discriminant(d), Some(IssueKind::UnusedFile));

// Unknown strings return None
assert_eq!(IssueKind::parse("not-a-kind"), None);

Variants

UnusedFile

An unused file.

UnusedExport

An unused export.

UnusedType

An unused type export.

PrivateTypeLeak

An exported signature that references a same-file private type.

UnusedDependency

An unused dependency.

UnusedDevDependency

An unused dev dependency.

UnusedEnumMember

An unused enum member.

UnusedClassMember

An unused class member.

UnresolvedImport

An unresolved import.

UnlistedDependency

An unlisted dependency.

DuplicateExport

A duplicate export name across modules.

CodeDuplication

Code duplication.

CircularDependency

A circular dependency chain.

ReExportCycle

A cycle or self-loop in the re-export edge subgraph (barrel files re-exporting from each other in a loop). Structurally always a bug: chain propagation through the cycle is a no-op.

TypeOnlyDependency

A production dependency only imported via type-only imports.

TestOnlyDependency

A production dependency only imported by test files.

BoundaryViolation

An import that crosses an architecture boundary.

CoverageGaps

A runtime file or export with no test dependency path.

FeatureFlag

A detected feature flag pattern.

Complexity

A function exceeding complexity thresholds (health command).

StaleSuppression

A suppression comment or JSDoc tag that no longer matches any issue.

PnpmCatalogEntry

A pnpm catalog entry in pnpm-workspace.yaml not referenced by any workspace package.

EmptyCatalogGroup

A named pnpm catalog group in pnpm-workspace.yaml with no entries.

UnresolvedCatalogReference

A workspace package.json reference (catalog: / catalog:<name>) pointing at a catalog that does not declare the consumed package.

UnusedDependencyOverride

An entry in pnpm’s overrides: / pnpm.overrides whose target package is not declared in any workspace package.json.

MisconfiguredDependencyOverride

An entry in pnpm’s overrides: / pnpm.overrides whose key or value cannot be parsed into a valid pnpm shape.

SecurityClientServerLeak

A "use client" file that transitively imports a module reading a non-public process.env secret (security candidate).

SecuritySink

A syntactic tainted-sink candidate matched against the data-driven security matcher catalogue (security_matchers.toml). ONE suppression token covers all catalogue categories.

PolicyViolation

A banned call or banned import matched by a declarative rule pack (rulePacks config). The bare token covers every pack rule; scoped tokens can target one <pack>/<rule-id> identity.

InvalidClientExport

A "use client" file that exports a Next.js server-only / route-segment config name (e.g. metadata, revalidate, GET).

MixedClientServerBarrel

A barrel file that re-exports BOTH a "use client" origin module AND a server-only origin module (Next.js App Router footgun: one import drags the other’s directive context across the boundary).

MisplacedDirective

A "use client" / "use server" directive string written as an expression statement after a non-directive statement (an import, a const). It is no longer in the leading prologue, so the RSC bundler parses it as an ordinary string and silently ignores it.

UnusedStoreMember

A store member (Pinia state / getters / actions key, or a setup-store returned key) declared but never accessed by any consumer project-wide. Cross-graph: the store binding is imported (the module is reachable) yet a specific member is dead.

UnprovidedInject

A Vue inject(KEY) or Svelte getContext(KEY) whose symbol KEY is provide/setContext’d nowhere in the analyzed project. Cross-graph dead-half DI link: at runtime the inject returns undefined.

RouteCollision

Two or more Next.js App Router route files that resolve to the same URL within one app-root (a guaranteed next build failure).

DynamicSegmentNameConflict

Sibling Next.js dynamic route segments at one tree position using different param spellings ([id] vs [slug]; a dev / runtime error that next build does NOT catch).

UnrenderedComponent

A component defined in the project that is exported but never rendered (no JSX usage) anywhere across the analyzed project.

UnusedComponentProp

A Vue <script setup> defineProps declared prop that is referenced NOWHERE inside its own single-file component (neither <script> nor <template>). Single-file dead-input direction.

UnusedComponentEmit

A Vue <script setup> defineEmits declared event that is EMITTED nowhere inside its own single-file component (no emit('<name>') call). Single-file dead-input direction.

UnusedComponentInput

An Angular @Input() / signal input() / model() declared input that is read NOWHERE inside its own component (neither the inline/external template nor the class body). Single-file dead-input direction; the Angular analogue of unused-component-prop.

UnusedComponentOutput

An Angular @Output() / signal output() declared output that is EMITTED nowhere inside its own component (no this.<output>.emit(...)). Single-file dead-output direction; the Angular analogue of unused-component-emit.

UnusedServerAction

A Next.js Server Action (an export of a "use server" file) that no code in the project references (no import-and-call, no action={fn} binding, no <form action={fn}>). Cross-graph dead-export direction, reclassified from unused-export for "use server" files.

UnusedLoadDataKey

A SvelteKit +page.{ts,server.ts,js,server.js} load() return-object key that no consumer reads: not off the sibling +page.svelte’s data.<key>, nor project-wide via page.data.<key> / $page.data.<key>. A dead load key runs a real server/DB fetch cost for data nothing renders.

PropDrilling

A React/Preact prop forwarded unchanged through >= N intermediate pass-through components until a component that substantively consumes it. Health signal, rule defaults to off (opt-in). Cross-graph: the chain spans multiple components / files.

ThinWrapper

A React/Preact component whose entire body is return <Child {...props}/> (a single spread-forwarded child render, no own value-add): pure structural indirection, a candidate for inlining. Health signal, rule defaults to off (opt-in).

DuplicatePropShape

Three or more React/Preact components across two or more files whose statically-harvested prop NAME set is identical after stripping ubiquitous DOM / passthrough names (a missing shared Props type). Health signal, rule defaults to off (opt-in). Cross-graph: the group spans multiple components / files.

UnusedSvelteEvent

A Svelte component dispatching a custom event via createEventDispatcher() whose event name is listened to NOWHERE in the analyzed project. Cross-file dead-output direction: the component fires an event nothing handles.

Implementations

impl IssueKind

pub fn parse(s: &str) -> Option<Self>

Parse an issue kind from the string tokens used in CLI output and suppression comments.

pub const fn to_discriminant(self) -> u8

Convert to a u8 discriminant for compact cache storage.

pub const fn from_discriminant(d: u8) -> Option<Self>

Reconstruct from a cache discriminant.

Trait Implementations

impl Clone for IssueKind

fn clone(&self) -> IssueKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for IssueKind

impl Debug for IssueKind

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

Formats the value using the given formatter.

impl Eq for IssueKind

impl PartialEq for IssueKind

fn eq(&self, other: &IssueKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for IssueKind