diedeadcode 0.1.0

Conservative TypeScript dead code detection with transitive analysis and confidence scoring
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
133
134
135
136
137

//! Entry point discovery for dead code analysis.

mod framework;
mod package_json;

use crate::config::Config;
use crate::core::{CallGraph, Result};
use std::path::Path;

/// Discover and mark entry points in the call graph.
pub fn discover_entry_points(
    call_graph: &mut CallGraph,
    root_path: &Path,
    config: &Config,
) -> Result<()> {
    // 1. Explicit entry points from config
    for entry_file in &config.entry.files {
        mark_file_exports_as_entry_points(call_graph, entry_file);
    }

    // 2. Entry points from patterns
    for pattern in &config.entry.patterns {
        mark_pattern_as_entry_points(call_graph, root_path, pattern);
    }

    // 3. Auto-detect from package.json
    if config.entry.auto_detect {
        let package_json_path = root_path.join("package.json");
        if package_json_path.exists() {
            package_json::mark_package_json_entry_points(call_graph, &package_json_path)?;
        }
    }

    // 4. Framework-specific entry points
    if config.plugins.auto_detect || !config.plugins.enabled.is_empty() {
        framework::discover_framework_entry_points(call_graph, root_path, config)?;
    }

    // 5. Mark explicitly exported symbols from config
    for export_name in &config.entry.exports {
        mark_export_as_entry_point(call_graph, export_name);
    }

    // 6. Files with side effects are implicit entry points
    mark_side_effect_files_as_entry_points(call_graph);

    Ok(())
}

/// Mark all exports from a file as entry points.
fn mark_file_exports_as_entry_points(call_graph: &mut CallGraph, file_path: &Path) {
    // Find the file in the graph
    let file_id = call_graph
        .files
        .values()
        .find(|f| f.path == file_path)
        .map(|f| f.id);

    if let Some(file_id) = file_id {
        // Mark all exported symbols from this file as entry points
        let symbols_to_mark: Vec<_> = call_graph
            .symbols
            .values()
            .filter(|s| s.file_id == file_id && s.exported)
            .map(|s| s.id)
            .collect();

        for id in symbols_to_mark {
            call_graph.mark_entry_point(id);
        }
    }
}

/// Mark exports matching a glob pattern as entry points.
fn mark_pattern_as_entry_points(call_graph: &mut CallGraph, root_path: &Path, pattern: &str) {
    let full_pattern = root_path.join(pattern).display().to_string();

    if let Ok(glob_pattern) = glob::Pattern::new(&full_pattern) {
        let matching_files: Vec<_> = call_graph
            .files
            .values()
            .filter(|f| glob_pattern.matches_path(&f.path))
            .map(|f| f.id)
            .collect();

        for file_id in matching_files {
            let symbols_to_mark: Vec<_> = call_graph
                .symbols
                .values()
                .filter(|s| s.file_id == file_id && s.exported)
                .map(|s| s.id)
                .collect();

            for id in symbols_to_mark {
                call_graph.mark_entry_point(id);
            }
        }
    }
}

/// Mark a named export as an entry point across all files.
fn mark_export_as_entry_point(call_graph: &mut CallGraph, export_name: &str) {
    let symbols_to_mark: Vec<_> = call_graph
        .symbols
        .values()
        .filter(|s| s.exported && s.name == export_name)
        .map(|s| s.id)
        .collect();

    for id in symbols_to_mark {
        call_graph.mark_entry_point(id);
    }
}

/// Mark files with side effects as having entry points.
fn mark_side_effect_files_as_entry_points(call_graph: &mut CallGraph) {
    let side_effect_file_ids: Vec<_> = call_graph
        .files
        .values()
        .filter(|f| f.has_side_effects)
        .map(|f| f.id)
        .collect();

    for file_id in side_effect_file_ids {
        // Mark all top-level symbols in files with side effects
        let symbols_to_mark: Vec<_> = call_graph
            .symbols
            .values()
            .filter(|s| s.file_id == file_id)
            .map(|s| s.id)
            .collect();

        for id in symbols_to_mark {
            call_graph.mark_entry_point(id);
        }
    }
}