Function enumerate_paths_with_dominance 

pub fn enumerate_paths_with_dominance(
    graph: &SqliteGraph,
    entry: i64,
    dom_result: &DominatorResult,
    cd_result: &ControlDependenceResult,
    loops_result: &NaturalLoopsResult,
    config: &PathEnumerationDominanceConfig,
) -> Result<PathEnumerationResult, SqliteGraphError>

Enumerates all execution paths with dominance-based pruning.

This function performs depth-first search with backtracking and revisit counting, AND applies dominance-based constraints to prune impossible paths early.

Constraint Types

1. Dominance pruning: If node B dominates node A, then A cannot appear before B in any valid path (backward dominance traversal is impossible)
2. Control dependence pruning: If node A controls node B, then B must appear after A in the path
3. Loop constraint pruning: Once inside a loop (entered header), cannot exit without reaching proper loop exit node

Arguments

• graph - The control flow graph
• entry - Entry node ID
• dom_result - Pre-computed dominator information
• cd_result - Pre-computed control dependence information
• loops_result - Pre-computed natural loop information
• config - Configuration for bounds and constraint enablement

Returns

• Result<PathEnumerationResult, SqliteGraphError> - Enumeration result with pruning statistics

Example

use sqlitegraph::{SqliteGraph, algo::{
    enumerate_paths_with_dominance, dominators,
    control_dependence_from_exit, natural_loops_from_exit,
    PathEnumerationDominanceConfig
}};

let graph = SqliteGraph::open_in_memory()?;
// ... build CFG ...

// First compute analysis results
let dom_result = dominators(&graph, entry)?;
let cd_result = control_dependence_from_exit(&graph)?;
let loops_result = natural_loops_from_exit(&graph)?;

let config = PathEnumerationDominanceConfig::default();
let result = enumerate_paths_with_dominance(
    &graph, entry, &dom_result, &cd_result, &loops_result, &config
)?;

println!("Found {} paths, pruned {} impossible paths",
         result.paths.len(),
         result.pruning_stats.as_ref().unwrap().paths_pruned);

Pruning Effectiveness

Dominance constraints can reduce path explosion by 10-100x on complex CFGs with many branches, while preserving ALL feasible paths (no false positives).