@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/tests/cache_order_tests.rs

@@ -0,0 +1,147 @@
+use std::collections::HashSet;
+use std::time::Instant;
+
+/// This test demonstrates the performance benefits of caching ancestor lookups
+/// in the AST traversal. The test creates a complex Go file with many nested
+/// structures that will trigger many ancestor lookups during parsing.
+#[test]
+fn test_ancestor_cache_performance() {
+    // Create a sample Go file with nested structures that will trigger many ancestor lookups
+    let content = generate_complex_go_file(10, 5); // 10 structs with 5 levels of nesting each
+
+    // Create a set of line numbers to extract (all lines in the file)
+    let line_count = content.lines().count();
+    let line_numbers: HashSet<usize> = (1..=line_count).collect();
+
+    println!("Generated a Go file with {line_count} lines");
+    println!("File contains multiple nested structures to stress-test ancestor lookups");
+
+    // Run the extraction multiple times to get a reliable measurement
+    let iterations = 10;
+    let mut times = Vec::with_capacity(iterations);
+
+    println!("\nRunning {iterations} iterations of parsing with ancestor cache:");
+
+    for i in 1..=iterations {
+        let start = Instant::now();
+        let result = probe_code::language::parser::parse_file_for_code_blocks(
+            &content,
+            "go",
+            &line_numbers,
+            true,
+            None,
+        );
+        assert!(result.is_ok(), "Failed to parse file: {:?}", result.err());
+        let blocks = result.unwrap();
+        let duration = start.elapsed();
+        times.push(duration.as_secs_f64());
+
+        println!(
+            "  Iteration {}: {:.6} seconds, extracted {} code blocks",
+            i,
+            duration.as_secs_f64(),
+            blocks.len()
+        );
+    }
+
+    // Calculate statistics
+    times.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    let min_time = times.first().unwrap();
+    let max_time = times.last().unwrap();
+    let median_time = if iterations % 2 == 0 {
+        (times[iterations / 2 - 1] + times[iterations / 2]) / 2.0
+    } else {
+        times[iterations / 2]
+    };
+    let avg_time = times.iter().sum::<f64>() / iterations as f64;
+
+    println!("\nPerformance statistics with ancestor cache:");
+    println!("  Minimum time: {min_time:.6} seconds");
+    println!("  Maximum time: {max_time:.6} seconds");
+    println!("  Median time:  {median_time:.6} seconds");
+    println!("  Average time: {avg_time:.6} seconds");
+
+    println!(
+        "\nNote: Without caching, this would be significantly slower due to redundant traversals."
+    );
+    println!("The cache prevents repeated upward traversals for nodes within the same acceptable parent block.");
+}
+
+/// Generates a complex Go file with multiple nested structures to stress-test ancestor lookups
+fn generate_complex_go_file(struct_count: usize, nesting_levels: usize) -> String {
+    let mut content = String::from("package main\n\nimport \"fmt\"\n\n");
+
+    // Generate multiple struct definitions with deep nesting
+    for i in 1..=struct_count {
+        content.push_str(&format!("// Struct {i} with deep nesting\n"));
+        content.push_str(&format!("type Struct{i} struct {{\n"));
+
+        // Add some fields at the top level
+        for j in 1..=3 {
+            content.push_str(&format!("    Field{j} string\n"));
+        }
+
+        // Add nested structures
+        let mut indent = 4;
+        let mut current_struct = format!("Inner{i}");
+
+        for level in 1..=nesting_levels {
+            let spaces = " ".repeat(indent);
+            content.push_str(&format!("{spaces}// Level {level} nested structure\n"));
+            content.push_str(&format!("{spaces}{current_struct} struct {{\n"));
+
+            // Add fields to this level
+            indent += 4;
+            let inner_spaces = " ".repeat(indent);
+            for j in 1..=3 {
+                content.push_str(&format!("{inner_spaces}Field{j}_L{level} string\n"));
+            }
+
+            // Prepare for next level
+            current_struct = format!("Nested{i}_L{level}");
+
+            // Add the nested struct field at this level (except for the last level)
+            if level < nesting_levels {
+                content.push_str(&format!(
+                    "{inner_spaces}{current_struct} {current_struct}\n"
+                ));
+            }
+        }
+
+        // Close all the nested structures
+        for level in (0..=nesting_levels).rev() {
+            let spaces = " ".repeat(4 * level);
+            content.push_str(&format!("{spaces}}}\n"));
+        }
+
+        content.push('\n');
+    }
+
+    // Add a main function that uses these structures
+    content.push_str("func main() {\n");
+    for i in 1..=struct_count {
+        content.push_str(&format!("    // Initialize Struct{i}\n"));
+        content.push_str(&format!("    var s{i} Struct{i}\n"));
+        content.push_str(&format!("    s{i}.Field1 = \"value\"\n"));
+
+        // Access some nested fields
+        let mut var_path = format!("s{i}");
+        for level in 1..=nesting_levels {
+            if level == 1 {
+                var_path = format!("{var_path}.Inner{i}");
+            } else {
+                var_path = format!("{}.Nested{}_L{}", var_path, i, level - 1);
+            }
+            content.push_str(&format!(
+                "    {var_path}.Field1_L{level} = \"nested value at level {level}\"\n"
+            ));
+        }
+        content.push('\n');
+    }
+
+    // Print something to avoid unused variable warnings
+    content.push_str("    fmt.Println(\"Complex nested structures initialized\")\n");
+    content.push_str("}\n");
+
+    content
+}

package/data/probe/tests/cache_query_scoping_tests.rs

@@ -0,0 +1,221 @@
+use std::collections::HashSet;
+use std::time::Instant;
+
+/// This test verifies that the ancestor cache correctly handles different query scopes
+/// by running multiple queries with different line number sets on the same file.
+#[test]
+fn test_ancestor_cache_with_different_query_scopes() {
+    // Create a sample Go file with multiple functions and nested structures
+    let content = r#"
+package main
+
+import "fmt"
+
+// Function 1 - Top level function
+func Function1() {
+    fmt.Println("Function 1")
+
+    // Local variable
+    var x int = 10
+
+    // Nested block
+    {
+        var y int = 20
+        fmt.Println(x + y)
+    }
+}
+
+// Struct definition with nested types
+type ComplexStruct struct {
+    Field1 string
+    Field2 int
+    Inner struct {
+        SubField1 string
+        SubField2 int
+    }
+}
+
+// Function 2 - Uses the complex struct
+func Function2() {
+    var data ComplexStruct
+    data.Field1 = "test"
+    data.Field2 = 42
+    data.Inner.SubField1 = "nested"
+    data.Inner.SubField2 = 100
+
+    fmt.Println(data)
+}
+
+// Function 3 - Another function with different structure
+func Function3() {
+    // Different local variables
+    var a, b, c int = 1, 2, 3
+
+    // Different nested block
+    if a < b {
+        var d int = a + b + c
+        fmt.Println(d)
+    }
+}
+
+func main() {
+    Function1()
+    Function2()
+    Function3()
+}
+"#;
+
+    println!("Testing ancestor cache with different query scopes");
+
+    // Define different query scopes (line number sets)
+    let all_lines: HashSet<usize> = (1..=content.lines().count()).collect();
+
+    // Query 1: First function only (lines 6-16)
+    let mut query1_lines = HashSet::new();
+    for i in 6..=16 {
+        query1_lines.insert(i);
+    }
+
+    // Query 2: Struct definition only (lines 19-26)
+    let mut query2_lines = HashSet::new();
+    for i in 19..=26 {
+        query2_lines.insert(i);
+    }
+
+    // Query 3: Second function only (lines 29-38)
+    let mut query3_lines = HashSet::new();
+    for i in 29..=38 {
+        query3_lines.insert(i);
+    }
+
+    // Query 4: Third function only (lines 41-50)
+    let mut query4_lines = HashSet::new();
+    for i in 41..=50 {
+        query4_lines.insert(i);
+    }
+
+    // Run queries in sequence and measure performance
+    println!("\nRunning queries with different line number sets:");
+
+    // Query 1
+    let start = Instant::now();
+    let result1 = probe_code::language::parser::parse_file_for_code_blocks(
+        content,
+        "go",
+        &query1_lines,
+        true,
+        None,
+    );
+    assert!(
+        result1.is_ok(),
+        "Failed to parse file for query 1: {:?}",
+        result1.err()
+    );
+    let blocks1 = result1.unwrap();
+    let duration1 = start.elapsed();
+    println!(
+        "  Query 1 (Function1): {:.6} seconds, extracted {} code blocks",
+        duration1.as_secs_f64(),
+        blocks1.len()
+    );
+
+    // Query 2
+    let start = Instant::now();
+    let result2 = probe_code::language::parser::parse_file_for_code_blocks(
+        content,
+        "go",
+        &query2_lines,
+        true,
+        None,
+    );
+    assert!(
+        result2.is_ok(),
+        "Failed to parse file for query 2: {:?}",
+        result2.err()
+    );
+    let blocks2 = result2.unwrap();
+    let duration2 = start.elapsed();
+    println!(
+        "  Query 2 (ComplexStruct): {:.6} seconds, extracted {} code blocks",
+        duration2.as_secs_f64(),
+        blocks2.len()
+    );
+
+    // Query 3
+    let start = Instant::now();
+    let result3 = probe_code::language::parser::parse_file_for_code_blocks(
+        content,
+        "go",
+        &query3_lines,
+        true,
+        None,
+    );
+    assert!(
+        result3.is_ok(),
+        "Failed to parse file for query 3: {:?}",
+        result3.err()
+    );
+    let blocks3 = result3.unwrap();
+    let duration3 = start.elapsed();
+    println!(
+        "  Query 3 (Function2): {:.6} seconds, extracted {} code blocks",
+        duration3.as_secs_f64(),
+        blocks3.len()
+    );
+
+    // Query 4
+    let start = Instant::now();
+    let result4 = probe_code::language::parser::parse_file_for_code_blocks(
+        content,
+        "go",
+        &query4_lines,
+        true,
+        None,
+    );
+    assert!(
+        result4.is_ok(),
+        "Failed to parse file for query 4: {:?}",
+        result4.err()
+    );
+    let blocks4 = result4.unwrap();
+    let duration4 = start.elapsed();
+    println!(
+        "  Query 4 (Function3): {:.6} seconds, extracted {} code blocks",
+        duration4.as_secs_f64(),
+        blocks4.len()
+    );
+
+    // Full file query
+    let start = Instant::now();
+    let result_all = probe_code::language::parser::parse_file_for_code_blocks(
+        content, "go", &all_lines, true, None,
+    );
+    assert!(
+        result_all.is_ok(),
+        "Failed to parse file for full query: {:?}",
+        result_all.err()
+    );
+    let blocks_all = result_all.unwrap();
+    let duration_all = start.elapsed();
+    println!(
+        "  Full file query: {:.6} seconds, extracted {} code blocks",
+        duration_all.as_secs_f64(),
+        blocks_all.len()
+    );
+
+    // Verify that the cache is working correctly by checking that the blocks extracted
+    // in the individual queries are consistent with those in the full file query
+    let total_blocks = blocks1.len() + blocks2.len() + blocks3.len() + blocks4.len();
+
+    // Account for potential overlaps in the extracted blocks
+    // In a perfect world, total_blocks would equal blocks_all.len(), but there might be
+    // some blocks that span multiple query regions or shared blocks
+
+    println!("\nVerification:");
+    println!("  Total blocks from individual queries: {total_blocks}");
+    println!("  Blocks from full file query: {}", blocks_all.len());
+    println!("  Note: Difference may be due to overlapping blocks or shared context");
+
+    // The test passes as long as we get results for all queries
+    // The actual verification is informational
+}