ast-bro 2.2.0

Fast, AST-based code-navigation: shape, public API, deps & call graphs, hybrid semantic search, structural rewrite. MCP server included.
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

use std::path::Path;

use ast_grep_core::Language;
use ast_grep_language::{LanguageExt, SupportLang};

use crate::adapters::base::LanguageAdapter;
use crate::adapters::cpp::CppAdapter;
use crate::adapters::csharp::CSharpAdapter;
use crate::adapters::go::GoAdapter;
use crate::adapters::java::JavaAdapter;
use crate::adapters::kotlin::KotlinAdapter;
use crate::adapters::php::PhpAdapter;
use crate::adapters::python::PythonAdapter;
use crate::adapters::ruby::RubyAdapter;
use crate::adapters::rust::RustAdapter;
use crate::adapters::scala::ScalaAdapter;
use crate::adapters::typescript::TypeScriptAdapter;
use crate::core::ParseResult;

/// Cheap extension-only check: would `parse_file_for_hook` accept this path?
/// Lets the hook skip files we can't render without reading them.
/// False positives (extension recognized but no wired adapter) fall through
/// to `PassThrough` when `parse_file_for_hook` returns `None`.
pub fn can_parse_for_hook(path: &Path) -> bool {
    let ext = path
        .extension()
        .and_then(|o| o.to_str())
        .unwrap_or("")
        .to_ascii_lowercase();
    if matches!(
        ext.as_str(),
        "sql" | "ddl" | "dml" | "md" | "markdown" | "mdx" | "mdown"
    ) {
        return true;
    }
    SupportLang::from_path(path).is_some()
}

pub fn parse_file_for_hook(path: &Path) -> Option<ParseResult> {
    let source = std::fs::read_to_string(path).ok()?;
    let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");

    // Handle SQL files (regex-based parsing). `parse_sql` takes `&str`
    // directly — UTF-8 was already validated by `read_to_string` above.
    if matches!(ext, "sql" | "ddl" | "dml") {
        let mut r = crate::adapters::sql::parse_sql(path, &source);
        crate::core::populate_markers(&mut r.declarations, r.language);
        return Some(r);
    }

    if matches!(ext, "md" | "markdown" | "mdx" | "mdown") {
        let mut r = crate::adapters::markdown::parse_markdown(path, source.as_bytes());
        crate::core::populate_markers(&mut r.declarations, r.language);
        return Some(r);
    }

    let lang = SupportLang::from_path(path)?;
    let mut result = match lang {
        SupportLang::Rust => RustAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Python => PythonAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::TypeScript | SupportLang::Tsx | SupportLang::JavaScript => {
            TypeScriptAdapter.parse(path, source.as_bytes(), lang.ast_grep(source.clone()).root())
        }
        SupportLang::CSharp => CSharpAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Go => GoAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Java => JavaAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Kotlin => KotlinAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Scala => ScalaAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Cpp => CppAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Ruby => RubyAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        SupportLang::Php => PhpAdapter.parse(
            path,
            source.as_bytes(),
            lang.ast_grep(source.clone()).root(),
        ),
        _ => return None,
    };
    // One central pass enriches every adapter's output with `native_kind`,
    // `modifiers`, and `deprecated` derived from the language's source
    // conventions. Adapters stay focused on tree traversal.
    crate::core::populate_markers(&mut result.declarations, result.language);
    Some(result)
}