Enum DebtType 

pub enum DebtType {
    Todo {
        reason: Option<String>,
    },
    Fixme {
        reason: Option<String>,
    },
    CodeSmell {
        smell_type: Option<String>,
    },
    Complexity {
        cyclomatic: u32,
        cognitive: u32,
    },
    Dependency {
        dependency_type: Option<String>,
    },
    ResourceManagement {
        issue_type: Option<String>,
    },
    CodeOrganization {
        issue_type: Option<String>,
    },
    TestComplexity {
        cyclomatic: u32,
        cognitive: u32,
    },
    TestQuality {
        issue_type: Option<String>,
    },
    TestingGap {
        coverage: f64,
        cyclomatic: u32,
        cognitive: u32,
    },
    ComplexityHotspot {
        cyclomatic: u32,
        cognitive: u32,
    },
    DeadCode {
        visibility: FunctionVisibility,
        cyclomatic: u32,
        cognitive: u32,
        usage_hints: Vec<String>,
    },
    Duplication {
        instances: u32,
        total_lines: u32,
    },
    Risk {
        risk_score: f64,
        factors: Vec<String>,
    },
    TestComplexityHotspot {
        cyclomatic: u32,
        cognitive: u32,
        threshold: u32,
    },
    TestTodo {
        priority: Priority,
        reason: Option<String>,
    },
    TestDuplication {
        instances: u32,
        total_lines: u32,
        similarity: f64,
    },
    ErrorSwallowing {
        pattern: String,
        context: Option<String>,
    },
    AllocationInefficiency {
        pattern: String,
        impact: String,
    },
    StringConcatenation {
        loop_type: String,
        iterations: Option<u32>,
    },
    NestedLoops {
        depth: u32,
        complexity_estimate: String,
    },
    BlockingIO {
        operation: String,
        context: String,
    },
    SuboptimalDataStructure {
        current_type: String,
        recommended_type: String,
    },
    GodObject {
        methods: u32,
        fields: Option<u32>,
        responsibilities: u32,
        god_object_score: f64,
        lines: u32,
    },
    FeatureEnvy {
        external_class: String,
        usage_ratio: f64,
    },
    PrimitiveObsession {
        primitive_type: String,
        domain_concept: String,
    },
    MagicValues {
        value: String,
        occurrences: u32,
    },
    AssertionComplexity {
        assertion_count: u32,
        complexity_score: f64,
    },
    FlakyTestPattern {
        pattern_type: String,
        reliability_impact: String,
    },
    AsyncMisuse {
        pattern: String,
        performance_impact: String,
    },
    ResourceLeak {
        resource_type: String,
        cleanup_missing: String,
    },
    CollectionInefficiency {
        collection_type: String,
        inefficiency_type: String,
    },
    ScatteredType {
        type_name: String,
        total_methods: usize,
        file_count: usize,
        severity: String,
    },
    OrphanedFunctions {
        target_type: String,
        function_count: usize,
        file_count: usize,
    },
    UtilitiesSprawl {
        function_count: usize,
        distinct_types: usize,
    },
}

Types of technical debt that debtmap can identify.

Each variant captures specific metrics relevant to that type of debt. The enum is designed to be:

• Exhaustive: covers all detected debt patterns
• Self-describing: variant names indicate the issue type
• Data-rich: captures relevant metrics for prioritization

Variants

Todo

Fields

reason: Option<String>

Fixme

Fields

reason: Option<String>

CodeSmell

Fields

smell_type: Option<String>

Complexity

Fields

cyclomatic: u32

cognitive: u32

Dependency

Fields

dependency_type: Option<String>

ResourceManagement

Fields

issue_type: Option<String>

CodeOrganization

Fields

issue_type: Option<String>

TestComplexity

Fields

cyclomatic: u32

cognitive: u32

TestQuality

Fields

issue_type: Option<String>

TestingGap

Fields

coverage: f64

cyclomatic: u32

cognitive: u32

ComplexityHotspot

Fields

cyclomatic: u32

cognitive: u32

DeadCode

Fields

visibility: FunctionVisibility

cyclomatic: u32

cognitive: u32

usage_hints: Vec<String>

Duplication

Fields

instances: u32

total_lines: u32

Risk

Fields

risk_score: f64

factors: Vec<String>

TestComplexityHotspot

Fields

cyclomatic: u32

cognitive: u32

threshold: u32

TestTodo

Fields

priority: Priority

reason: Option<String>

TestDuplication

Fields

instances: u32

total_lines: u32

similarity: f64

ErrorSwallowing

Fields

pattern: String

context: Option<String>

AllocationInefficiency

Fields

pattern: String

impact: String

StringConcatenation

Fields

loop_type: String

iterations: Option<u32>

NestedLoops

Fields

depth: u32

complexity_estimate: String

BlockingIO

Fields

operation: String

context: String

SuboptimalDataStructure

Fields

current_type: String

recommended_type: String

GodObject

Unified god object variant representing all detection types (GodClass, GodFile, GodModule) The god_object_indicators.detection_type field distinguishes between these types

Fields

methods: u32

Number of methods (for GodClass) or functions (for GodFile/GodModule)

fields: Option<u32>

Number of fields - Some for GodClass, None for GodFile/GodModule

responsibilities: u32

god_object_score: f64

lines: u32

Total lines of code

FeatureEnvy

Fields

external_class: String

usage_ratio: f64

PrimitiveObsession

Fields

primitive_type: String

domain_concept: String

MagicValues

Fields

value: String

occurrences: u32

AssertionComplexity

Fields

assertion_count: u32

complexity_score: f64

FlakyTestPattern

Fields

pattern_type: String

reliability_impact: String

AsyncMisuse

Fields

pattern: String

performance_impact: String

ResourceLeak

Fields

resource_type: String

cleanup_missing: String

CollectionInefficiency

Fields

collection_type: String

inefficiency_type: String

ScatteredType

Fields

type_name: String

total_methods: usize

file_count: usize

severity: String

OrphanedFunctions

Fields

target_type: String

function_count: usize

file_count: usize

UtilitiesSprawl

Fields

function_count: usize

distinct_types: usize

Implementations

impl DebtType

pub fn display_name(&self) -> &'static str

Pure function: returns the display name for this debt type.

For most variants, this returns a static string. The ErrorSwallowing variant is the exception - it requires dynamic content and is handled separately in the Display impl.

This separation follows the Stillwater pattern: pure core logic in a helper function, I/O (formatting) at the boundary.

Trait Implementations

impl Clone for DebtType

fn clone(&self) -> DebtType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DebtType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DebtType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DebtType

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

Formats the value using the given formatter.

impl Hash for DebtType

Custom Hash implementation that handles f64 fields by hashing their bit representations.

Design Notes

This function has high cyclomatic complexity due to matching on all 33 enum variants. This is intentional structural complexity that cannot be reduced without sacrificing:

• Type safety (each variant’s fields must be explicitly destructured)
• Correctness (f64 fields require bit conversion via @f64 marker)
• Exhaustive matching (compiler ensures all variants are handled)

The complexity is mitigated by:

• Using the hash_fields! macro to reduce repetition
• Grouping similar variants with or-patterns where field types match
• Comprehensive test coverage for all variant groups

Variant groups:

• Option<String> single field: 7 variants
• (u32, u32) pairs: 4 variants (Complexity, TestComplexity, ComplexityHotspot, Duplication)
• (String, String) pairs: 8 variants
• Remaining unique structures: handled individually

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DebtType

fn eq(&self, other: &DebtType) -> 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 Serialize for DebtType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DebtType

impl StructuralPartialEq for DebtType