fallow_core/

cross_reference.rs

//! Cross-reference duplication findings with dead code analysis results.
//!
//! When code is both duplicated AND unused, it's a higher-priority finding:
//! the duplicate can be safely removed without any refactoring. This module
//! identifies such combined findings.

use rustc_hash::FxHashSet;
use std::path::PathBuf;

use serde::Serialize;

use crate::duplicates::types::{CloneInstance, DuplicationReport};
use crate::results::AnalysisResults;

/// A combined finding where a clone instance overlaps with a dead code issue.
#[derive(Debug, Clone, Serialize)]
pub struct CombinedFinding {
    /// The clone instance that is also unused.
    pub clone_instance: CloneInstance,
    /// What kind of dead code overlaps with this clone.
    pub dead_code_kind: DeadCodeKind,
    /// Clone group index (for associating with the parent group).
    pub group_index: usize,
}

/// The type of dead code that overlaps with a clone instance.
#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
pub enum DeadCodeKind {
    /// The entire file containing the clone is unused.
    UnusedFile,
    /// A specific unused export overlaps with the clone's line range.
    UnusedExport { export_name: String },
    /// A specific unused type overlaps with the clone's line range.
    UnusedType { type_name: String },
}

/// Result of cross-referencing duplication with dead code analysis.
#[derive(Debug, Clone, Serialize)]
pub struct CrossReferenceResult {
    /// Clone instances that are also dead code (safe to delete).
    pub combined_findings: Vec<CombinedFinding>,
    /// Number of clone instances in unused files.
    pub clones_in_unused_files: usize,
    /// Number of clone instances overlapping unused exports.
    pub clones_with_unused_exports: usize,
}

/// Cross-reference duplication findings with dead code analysis results.
///
/// For each clone instance, checks whether:
/// 1. The file is entirely unused (in `unused_files`)
/// 2. An unused export/type at the same line range overlaps
///
/// Returns combined findings sorted by priority (unused files first, then exports).
#[must_use]
pub fn cross_reference(
    duplication: &DuplicationReport,
    dead_code: &AnalysisResults,
) -> CrossReferenceResult {
    let unused_files: FxHashSet<&PathBuf> = dead_code
        .unused_files
        .iter()
        .map(|f| &f.file.path)
        .collect();

    let mut combined_findings = Vec::new();
    let mut clones_in_unused_files = 0usize;
    let mut clones_with_unused_exports = 0usize;

    for (group_idx, group) in duplication.clone_groups.iter().enumerate() {
        for instance in &group.instances {
            if unused_files.contains(&instance.file) {
                combined_findings.push(CombinedFinding {
                    clone_instance: instance.clone(),
                    dead_code_kind: DeadCodeKind::UnusedFile,
                    group_index: group_idx,
                });
                clones_in_unused_files += 1;
                continue; // No need to check exports if entire file is unused
            }

            if let Some(finding) = find_overlapping_unused_export(instance, group_idx, dead_code) {
                clones_with_unused_exports += 1;
                combined_findings.push(finding);
            }
        }
    }

    CrossReferenceResult {
        combined_findings,
        clones_in_unused_files,
        clones_with_unused_exports,
    }
}

/// Check if any unused export/type overlaps with the clone instance's line range.
fn find_overlapping_unused_export(
    instance: &CloneInstance,
    group_index: usize,
    dead_code: &AnalysisResults,
) -> Option<CombinedFinding> {
    for export in &dead_code.unused_exports {
        if export.export.path == instance.file
            && (export.export.line as usize) >= instance.start_line
            && (export.export.line as usize) <= instance.end_line
        {
            return Some(CombinedFinding {
                clone_instance: instance.clone(),
                dead_code_kind: DeadCodeKind::UnusedExport {
                    export_name: export.export.export_name.clone(),
                },
                group_index,
            });
        }
    }

    for type_export in &dead_code.unused_types {
        if type_export.export.path == instance.file
            && (type_export.export.line as usize) >= instance.start_line
            && (type_export.export.line as usize) <= instance.end_line
        {
            return Some(CombinedFinding {
                clone_instance: instance.clone(),
                dead_code_kind: DeadCodeKind::UnusedType {
                    type_name: type_export.export.export_name.clone(),
                },
                group_index,
            });
        }
    }

    None
}

/// Summary statistics for cross-referenced findings.
impl CrossReferenceResult {
    /// Total number of combined findings.
    #[must_use]
    pub const fn total(&self) -> usize {
        self.combined_findings.len()
    }

    /// Whether any combined findings exist.
    #[must_use]
    pub const fn has_findings(&self) -> bool {
        !self.combined_findings.is_empty()
    }

    /// Get clone groups that have at least one combined finding, with their indices.
    #[must_use]
    pub fn affected_group_indices(&self) -> FxHashSet<usize> {
        self.combined_findings
            .iter()
            .map(|f| f.group_index)
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::duplicates::CloneGroup;
    use crate::results::{UnusedExport, UnusedFile};
    use fallow_types::output_dead_code::{
        UnusedExportFinding, UnusedFileFinding, UnusedTypeFinding,
    };

    fn make_instance(file: &str, start: usize, end: usize) -> CloneInstance {
        CloneInstance {
            file: PathBuf::from(file),
            start_line: start,
            end_line: end,
            start_col: 0,
            end_col: 0,
            fragment: String::new(),
        }
    }

    fn make_group(instances: Vec<CloneInstance>) -> CloneGroup {
        CloneGroup {
            instances,
            token_count: 50,
            line_count: 10,
        }
    }

    #[test]
    fn empty_inputs_produce_no_findings() {
        let duplication = DuplicationReport {
            clone_groups: vec![],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 0,
                files_with_clones: 0,
                total_lines: 0,
                duplicated_lines: 0,
                total_tokens: 0,
                duplicated_tokens: 0,
                clone_groups: 0,
                clone_instances: 0,
                duplication_percentage: 0.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let dead_code = AnalysisResults::default();

        let result = cross_reference(&duplication, &dead_code);
        assert!(!result.has_findings());
        assert_eq!(result.total(), 0);
    }

    #[test]
    fn detects_clone_in_unused_file() {
        let duplication = DuplicationReport {
            clone_groups: vec![make_group(vec![
                make_instance("src/a.ts", 1, 10),
                make_instance("src/b.ts", 1, 10),
            ])],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 2,
                files_with_clones: 2,
                total_lines: 20,
                duplicated_lines: 10,
                total_tokens: 100,
                duplicated_tokens: 50,
                clone_groups: 1,
                clone_instances: 2,
                duplication_percentage: 50.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_files
            .push(UnusedFileFinding::with_actions(UnusedFile {
                path: PathBuf::from("src/a.ts"),
            }));

        let result = cross_reference(&duplication, &dead_code);
        assert!(result.has_findings());
        assert_eq!(result.clones_in_unused_files, 1);
        assert_eq!(
            result.combined_findings[0].dead_code_kind,
            DeadCodeKind::UnusedFile
        );
    }

    #[test]
    fn detects_clone_overlapping_unused_export() {
        let duplication = DuplicationReport {
            clone_groups: vec![make_group(vec![
                make_instance("src/a.ts", 5, 15),
                make_instance("src/b.ts", 5, 15),
            ])],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 2,
                files_with_clones: 2,
                total_lines: 20,
                duplicated_lines: 10,
                total_tokens: 100,
                duplicated_tokens: 50,
                clone_groups: 1,
                clone_instances: 2,
                duplication_percentage: 50.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_exports
            .push(UnusedExportFinding::with_actions(UnusedExport {
                path: PathBuf::from("src/a.ts"),
                export_name: "processData".to_string(),
                is_type_only: false,
                line: 5,
                col: 0,
                span_start: 0,
                is_re_export: false,
            }));

        let result = cross_reference(&duplication, &dead_code);
        assert!(result.has_findings());
        assert_eq!(result.clones_with_unused_exports, 1);
        assert!(matches!(
            &result.combined_findings[0].dead_code_kind,
            DeadCodeKind::UnusedExport { export_name } if export_name == "processData"
        ));
    }

    #[test]
    fn no_findings_when_no_overlap() {
        let duplication = DuplicationReport {
            clone_groups: vec![make_group(vec![
                make_instance("src/a.ts", 5, 15),
                make_instance("src/b.ts", 5, 15),
            ])],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 2,
                files_with_clones: 2,
                total_lines: 20,
                duplicated_lines: 10,
                total_tokens: 100,
                duplicated_tokens: 50,
                clone_groups: 1,
                clone_instances: 2,
                duplication_percentage: 50.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_exports
            .push(UnusedExportFinding::with_actions(UnusedExport {
                path: PathBuf::from("src/a.ts"),
                export_name: "other".to_string(),
                is_type_only: false,
                line: 20,
                col: 0,
                span_start: 0,
                is_re_export: false,
            }));

        let result = cross_reference(&duplication, &dead_code);
        assert!(!result.has_findings());
    }

    #[test]
    fn affected_group_indices() {
        let duplication = DuplicationReport {
            clone_groups: vec![
                make_group(vec![
                    make_instance("src/a.ts", 1, 10),
                    make_instance("src/b.ts", 1, 10),
                ]),
                make_group(vec![
                    make_instance("src/c.ts", 1, 10),
                    make_instance("src/d.ts", 1, 10),
                ]),
            ],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 4,
                files_with_clones: 4,
                total_lines: 40,
                duplicated_lines: 20,
                total_tokens: 200,
                duplicated_tokens: 100,
                clone_groups: 2,
                clone_instances: 4,
                duplication_percentage: 50.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_files
            .push(UnusedFileFinding::with_actions(UnusedFile {
                path: PathBuf::from("src/c.ts"),
            }));

        let result = cross_reference(&duplication, &dead_code);
        let affected = result.affected_group_indices();
        assert!(!affected.contains(&0));
        assert!(affected.contains(&1));
    }

    #[test]
    fn unused_file_takes_priority_over_export() {
        let duplication = DuplicationReport {
            clone_groups: vec![make_group(vec![
                make_instance("src/a.ts", 5, 15),
                make_instance("src/b.ts", 5, 15),
            ])],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 2,
                files_with_clones: 2,
                total_lines: 20,
                duplicated_lines: 10,
                total_tokens: 100,
                duplicated_tokens: 50,
                clone_groups: 1,
                clone_instances: 2,
                duplication_percentage: 50.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_files
            .push(UnusedFileFinding::with_actions(UnusedFile {
                path: PathBuf::from("src/a.ts"),
            }));
        dead_code
            .unused_exports
            .push(UnusedExportFinding::with_actions(UnusedExport {
                path: PathBuf::from("src/a.ts"),
                export_name: "foo".to_string(),
                is_type_only: false,
                line: 10,
                col: 0,
                span_start: 0,
                is_re_export: false,
            }));

        let result = cross_reference(&duplication, &dead_code);
        let a_findings: Vec<_> = result
            .combined_findings
            .iter()
            .filter(|f| f.clone_instance.file == std::path::Path::new("src/a.ts"))
            .collect();
        assert_eq!(a_findings.len(), 1);
        assert_eq!(a_findings[0].dead_code_kind, DeadCodeKind::UnusedFile);
    }

    #[test]
    fn detects_clone_overlapping_unused_type() {
        let duplication = DuplicationReport {
            clone_groups: vec![make_group(vec![
                make_instance("src/types.ts", 1, 20),
                make_instance("src/other.ts", 1, 20),
            ])],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 2,
                files_with_clones: 2,
                total_lines: 40,
                duplicated_lines: 20,
                total_tokens: 100,
                duplicated_tokens: 50,
                clone_groups: 1,
                clone_instances: 2,
                duplication_percentage: 50.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_types
            .push(UnusedTypeFinding::with_actions(UnusedExport {
                path: PathBuf::from("src/types.ts"),
                export_name: "OldInterface".to_string(),
                is_type_only: true,
                line: 10,
                col: 0,
                span_start: 0,
                is_re_export: false,
            }));

        let result = cross_reference(&duplication, &dead_code);
        assert!(result.has_findings());
        assert!(matches!(
            &result.combined_findings[0].dead_code_kind,
            DeadCodeKind::UnusedType { type_name } if type_name == "OldInterface"
        ));
    }

    #[test]
    fn empty_result_methods() {
        let result = CrossReferenceResult {
            combined_findings: vec![],
            clones_in_unused_files: 0,
            clones_with_unused_exports: 0,
        };
        assert_eq!(result.total(), 0);
        assert!(!result.has_findings());
        assert!(result.affected_group_indices().is_empty());
    }

    #[test]
    fn multiple_groups_with_findings() {
        let duplication = DuplicationReport {
            clone_groups: vec![
                make_group(vec![
                    make_instance("src/a.ts", 1, 10),
                    make_instance("src/b.ts", 1, 10),
                ]),
                make_group(vec![
                    make_instance("src/c.ts", 5, 15),
                    make_instance("src/d.ts", 5, 15),
                ]),
                make_group(vec![
                    make_instance("src/e.ts", 1, 10),
                    make_instance("src/f.ts", 1, 10),
                ]),
            ],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats {
                total_files: 6,
                files_with_clones: 6,
                total_lines: 60,
                duplicated_lines: 30,
                total_tokens: 300,
                duplicated_tokens: 150,
                clone_groups: 3,
                clone_instances: 6,
                duplication_percentage: 50.0,
                clone_groups_below_min_occurrences: 0,
            },
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_files
            .push(UnusedFileFinding::with_actions(UnusedFile {
                path: PathBuf::from("src/a.ts"),
            }));
        dead_code
            .unused_exports
            .push(UnusedExportFinding::with_actions(UnusedExport {
                path: PathBuf::from("src/c.ts"),
                export_name: "helper".to_string(),
                is_type_only: false,
                line: 10,
                col: 0,
                span_start: 0,
                is_re_export: false,
            }));

        let result = cross_reference(&duplication, &dead_code);
        assert_eq!(result.total(), 2);
        assert_eq!(result.clones_in_unused_files, 1);
        assert_eq!(result.clones_with_unused_exports, 1);

        let affected = result.affected_group_indices();
        assert!(affected.contains(&0));
        assert!(affected.contains(&1));
        assert!(!affected.contains(&2));
    }

    #[test]
    fn clone_instance_outside_export_line_range() {
        let duplication = DuplicationReport {
            clone_groups: vec![make_group(vec![
                make_instance("src/a.ts", 1, 5),
                make_instance("src/b.ts", 1, 5),
            ])],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats::default(),
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_exports
            .push(UnusedExportFinding::with_actions(UnusedExport {
                path: PathBuf::from("src/a.ts"),
                export_name: "fn".to_string(),
                is_type_only: false,
                line: 10,
                col: 0,
                span_start: 0,
                is_re_export: false,
            }));

        let result = cross_reference(&duplication, &dead_code);
        assert!(!result.has_findings());
    }

    #[test]
    fn clone_in_different_file_than_unused_export() {
        let duplication = DuplicationReport {
            clone_groups: vec![make_group(vec![
                make_instance("src/a.ts", 5, 15),
                make_instance("src/b.ts", 5, 15),
            ])],
            clone_families: vec![],
            mirrored_directories: vec![],
            stats: crate::duplicates::types::DuplicationStats::default(),
        };
        let mut dead_code = AnalysisResults::default();
        dead_code
            .unused_exports
            .push(UnusedExportFinding::with_actions(UnusedExport {
                path: PathBuf::from("src/x.ts"),
                export_name: "fn".to_string(),
                is_type_only: false,
                line: 10,
                col: 0,
                span_start: 0,
                is_re_export: false,
            }));

        let result = cross_reference(&duplication, &dead_code);
        assert!(!result.has_findings());
    }
}