neti 1.6.6

High-integrity code quality governance and transactional change management for AI-assisted development
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

// src/mutate/discovery.rs
//! Discovers mutation points in source files using tree-sitter.
//!
//! Walks the AST to find operators, booleans, and other mutable constructs.

use crate::lang::Lang;
use crate::mutate::mutations::{get_mutation, MutationPoint};
use anyhow::{Context, Result};
use std::fs;
use std::path::Path;
use tree_sitter::{Node, Parser};

/// Discovers all mutation points in a single file.
///
/// # Errors
/// Returns error if file cannot be read or parsed.
pub fn discover_mutations(path: &Path) -> Result<Vec<MutationPoint>> {
    let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
    let Some(lang) = Lang::from_ext(ext) else {
        return Ok(Vec::new()); // Skip unsupported files
    };

    let source = fs::read_to_string(path)
        .with_context(|| format!("Failed to read {}", path.display()))?;

    let mut parser = Parser::new();
    parser
        .set_language(lang.grammar())
        .context("Failed to set parser language")?;

    let tree = parser
        .parse(&source, None)
        .context("Failed to parse file")?;

    let mut points = Vec::new();
    collect_mutations(tree.root_node(), &source, path, &mut points);

    Ok(points)
}

/// Recursively walks the AST collecting mutation points.
fn collect_mutations(node: Node, source: &str, path: &Path, out: &mut Vec<MutationPoint>) {
    // Check if this node is a mutable operator/literal
    if let Some(point) = check_node(node, source, path) {
        out.push(point);
    }

    // Recurse into children
    let mut cursor = node.walk();
    for child in node.children(&mut cursor) {
        collect_mutations(child, source, path, out);
    }
}

/// Checks if a node represents a mutable point.
fn check_node(node: Node, source: &str, path: &Path) -> Option<MutationPoint> {
    let kind = node.kind();

    // Target operator nodes and boolean literals
    if !is_mutable_kind(kind) {
        return None;
    }

    let text = node.utf8_text(source.as_bytes()).ok()?;
    let (mutated, mutation_kind) = get_mutation(text)?;

    Some(MutationPoint {
        file: path.to_path_buf(),
        line: node.start_position().row + 1,
        column: node.start_position().column + 1,
        byte_start: node.start_byte(),
        byte_end: node.end_byte(),
        original: text.to_string(),
        mutated: mutated.to_string(),
        kind: mutation_kind,
    })
}

/// Returns true if this AST node kind might contain a mutable operator.
fn is_mutable_kind(kind: &str) -> bool {
    matches!(
        kind,
        // Operators (varies by language)
        "==" | "!=" | "<" | ">" | "<=" | ">="
            | "&&" | "||"
            | "+" | "-" | "*" | "/"
            | "and" | "or"
            // Boolean literals
            | "true" | "false"
            | "boolean" | "True" | "False"
            // Generic operator captures from tree-sitter
            | "binary_operator"
            | "comparison_operator"
            | "boolean_operator"
    )
}

#[cfg(test)]
#[allow(clippy::expect_used)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn test_discover_finds_operators() {
        let source = "fn test() { x == 1 && y > 2 }";
        let mut parser = Parser::new();
        parser.set_language(Lang::Rust.grammar()).ok();
        let tree = parser.parse(source, None).expect("parse");

        let mut points = Vec::new();
        let path = PathBuf::from("test.rs");
        collect_mutations(tree.root_node(), source, &path, &mut points);

        // Should find at least == and >
        assert!(!points.is_empty());
    }
}