codemov-parser 0.1.0

Tree-sitter based source code parser for codemov
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

use codemov_core::{ImportEdge, ImportKind, Symbol, SymbolKind};
use tree_sitter::Node;

use crate::ParseError;

pub fn extract(source: &[u8]) -> Result<Vec<Symbol>, ParseError> {
    let mut parser = tree_sitter::Parser::new();
    parser
        .set_language(&tree_sitter_rust::language())
        .map_err(|e| ParseError::Parse(e.to_string()))?;

    let tree = parser
        .parse(source, None)
        .ok_or_else(|| ParseError::Parse("tree-sitter returned None".into()))?;

    let mut symbols = Vec::new();
    walk(tree.root_node(), source, &mut symbols);
    Ok(symbols)
}

fn walk(node: Node, source: &[u8], out: &mut Vec<Symbol>) {
    match node.kind() {
        "function_item" => {
            if let Some(sym) = named(node, source, SymbolKind::Function, "name") {
                out.push(sym);
            }
        }
        "struct_item" => {
            if let Some(sym) = named(node, source, SymbolKind::Struct, "name") {
                out.push(sym);
            }
        }
        "enum_item" => {
            if let Some(sym) = named(node, source, SymbolKind::Enum, "name") {
                out.push(sym);
            }
        }
        "trait_item" => {
            if let Some(sym) = named(node, source, SymbolKind::Trait, "name") {
                out.push(sym);
            }
        }
        "impl_item" => {
            let name = node
                .child_by_field_name("type")
                .and_then(|n| n.utf8_text(source).ok())
                .unwrap_or("_")
                .to_string();
            out.push(Symbol {
                name,
                kind: SymbolKind::Impl,
                start_line: node.start_position().row as u32 + 1,
                end_line: node.end_position().row as u32 + 1,
            });
        }
        _ => {}
    }

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

pub fn extract_imports(source: &[u8]) -> Result<Vec<ImportEdge>, crate::ParseError> {
    let mut parser = tree_sitter::Parser::new();
    parser
        .set_language(&tree_sitter_rust::language())
        .map_err(|e| crate::ParseError::Parse(e.to_string()))?;
    let tree = parser
        .parse(source, None)
        .ok_or_else(|| crate::ParseError::Parse("tree-sitter returned None".into()))?;

    let mut edges = Vec::new();
    collect_use_decls(tree.root_node(), source, &mut edges);
    Ok(edges)
}

fn collect_use_decls(node: Node, source: &[u8], out: &mut Vec<ImportEdge>) {
    if node.kind() == "use_declaration" {
        if let Ok(text) = node.utf8_text(source) {
            // Strip leading "use " and trailing ";"
            let raw = text
                .trim()
                .strip_prefix("use ")
                .unwrap_or(text.trim())
                .trim_end_matches(';')
                .trim()
                .to_string();
            out.push(ImportEdge {
                source_path: std::path::PathBuf::new(),
                target_raw: raw,
                resolved_path: None,
                kind: ImportKind::Use,
                line: node.start_position().row as u32 + 1,
            });
        }
    }
    let mut cursor = node.walk();
    for child in node.children(&mut cursor) {
        collect_use_decls(child, source, out);
    }
}

fn named(node: Node, source: &[u8], kind: SymbolKind, field: &str) -> Option<Symbol> {
    let name = node
        .child_by_field_name(field)?
        .utf8_text(source)
        .ok()?
        .to_string();
    Some(Symbol {
        name,
        kind,
        start_line: node.start_position().row as u32 + 1,
        end_line: node.end_position().row as u32 + 1,
    })
}