Function get_independent_headers

src/analysis/header.rs:155–266

(trees: &[TreeNode])

fn get_independent_headers(trees: &[TreeNode]) -> Result<Vec<&str>> {
    use std::collections::{HashMap, HashSet};
    
    // Collect all nodes and their inclusion relationships
    let mut all_nodes: HashMap<&str, &TreeNode> = HashMap::new();
    let mut included_by_others: HashSet<&str> = HashSet::new();
    let mut includes_map: HashMap<&str, HashSet<&str>> = HashMap::new();
    
    // Recursively collect all nodes and dependency relationships
    fn collect_nodes<'a>(
        node: &'a TreeNode, 
        all_nodes: &mut HashMap<&'a str, &'a TreeNode>,
        included_by_others: &mut HashSet<&'a str>,
        includes_map: &mut HashMap<&'a str, HashSet<&'a str>>
    ) {
        let name = node.get_name();
        all_nodes.insert(name, node);
        
        let mut children_set = HashSet::new();
        
        // Collect all child nodes, which are included by the current node
        for child in &node.children {
            let child_name = child.get_name();
            included_by_others.insert(child_name);
            children_set.insert(child_name);
            collect_nodes(child, all_nodes, included_by_others, includes_map);
        }
        
        includes_map.insert(name, children_set);
    }
    
    // Collect nodes for each tree
    for tree in trees {
        collect_nodes(tree, &mut all_nodes, &mut included_by_others, &mut includes_map);
    }
    
    // Find all root nodes (nodes not included by any other nodes)
    let mut independent_headers: Vec<&str> = Vec::new();
    
    for name in all_nodes.keys() {
        if !included_by_others.contains(name) {
            independent_headers.push(name);
        }
    }
    
    // If independent headers are found, return them directly
    if !independent_headers.is_empty() {
        independent_headers.sort();
        independent_headers.dedup();
        return Ok(independent_headers);
    }
    
    // No independent headers found, possible circular dependencies exist
    // Use greedy algorithm to find minimum coverage set
    let mut result = Vec::new();
    let mut covered: HashSet<&str> = HashSet::new();
    let mut remaining_nodes: HashSet<&str> = all_nodes.keys().cloned().collect();