splice 2.6.3

Span-safe refactoring kernel for 7 languages with Magellan code graph integration
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Syntax validation using tree-sitter
//!
//! Provides tree-sitter parsing validation for multiple languages.

use crate::error::{Result, SpliceError};
use std::path::Path;
use tree_sitter::Parser;

/// Validate syntax by parsing with tree-sitter
///
/// # Arguments
/// * `file_path` - Path to the file (used for language detection)
/// * `source` - Source code to validate
///
/// # Returns
/// * `Ok(bool)` - true if syntax is valid, false if parse failed
/// * `Err(SpliceError)` - Validation process failed
pub fn validate_syntax(file_path: &Path, source: &[u8]) -> Result<bool> {
    // Detect language from file extension
    let language = detect_language(file_path)?;

    if language.is_none() {
        // Unknown language - skip validation (don't block)
        log::debug!(
            "Unknown language for {:?}, skipping syntax validation",
            file_path
        );
        return Ok(true);
    }

    let language = language.unwrap();

    // Create parser
    let mut parser = Parser::new();
    parser
        .set_language(&language)
        .map_err(|e| SpliceError::Parse {
            file: file_path.to_path_buf(),
            message: format!("Failed to set language: {:?}", e),
        })?;

    // Parse the source
    let tree = parser.parse(source, None);

    // Check if parse succeeded
    match tree {
        Some(tree) => {
            // Check for parse errors in the tree
            let has_errors = has_parse_errors(tree.root_node());
            if has_errors {
                log::warn!("Syntax errors detected in {:?}", file_path);
            }
            Ok(!has_errors)
        }
        None => {
            log::warn!("Parse failed for {:?}", file_path);
            Ok(false)
        }
    }
}

/// Detect tree-sitter language from file extension
fn detect_language(file_path: &Path) -> Result<Option<tree_sitter::Language>> {
    let extension = file_path
        .extension()
        .and_then(|ext| ext.to_str())
        .unwrap_or("");

    match extension {
        "rs" => Ok(Some(tree_sitter_rust::language())),
        "py" => Ok(Some(tree_sitter_python::language())),
        "c" | "h" => Ok(Some(tree_sitter_c::language())),
        "cpp" | "cc" | "cxx" | "hpp" => Ok(Some(tree_sitter_cpp::language())),
        "js" | "mjs" => Ok(Some(tree_sitter_javascript::language())),
        "ts" => Ok(Some(tree_sitter_typescript::language_tsx())),
        "tsx" => Ok(Some(tree_sitter_typescript::language_tsx())),
        "java" => Ok(Some(tree_sitter_java::language())),
        _ => Ok(None),
    }
}

/// Check if the parse tree contains ERROR nodes
fn has_parse_errors(node: tree_sitter::Node) -> bool {
    if node.kind() == "ERROR" || node.is_missing() {
        return true;
    }

    let mut cursor = node.walk();
    for child in node.children(&mut cursor) {
        if has_parse_errors(child) {
            return true;
        }
    }

    false
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs::File;
    use std::io::Write;
    use tempfile::TempDir;

    #[test]
    fn test_valid_rust_syntax() {
        let temp_dir = TempDir::new().unwrap();
        let file_path = temp_dir.path().join("test.rs");
        let mut file = File::create(&file_path).unwrap();
        writeln!(file, "fn main() {{ }}").unwrap();

        let source = b"fn main() {}";
        let result = validate_syntax(&file_path, source).unwrap();
        assert!(result, "Valid Rust syntax should pass validation");
    }

    #[test]
    fn test_invalid_rust_syntax() {
        let temp_dir = TempDir::new().unwrap();
        let file_path = temp_dir.path().join("test.rs");

        // Missing closing brace - should fail
        let source = b"fn main() {";
        let result = validate_syntax(&file_path, source).unwrap();
        assert!(!result, "Invalid Rust syntax should fail validation");
    }

    #[test]
    fn test_unknown_language() {
        let temp_dir = TempDir::new().unwrap();
        let file_path = temp_dir.path().join("test.xyz");

        let source = b"some code";
        let result = validate_syntax(&file_path, source).unwrap();
        assert!(result, "Unknown language should pass (skip validation)");
    }
}