abcop 0.17.0

Must-have ABC complexity gate for AI development. Ruby, Rust, Python, Go, JS/TS, C/C++, PHP, Java, C#, Swift, Zig, Dart, Solidity, ObjC
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
138
139
140
141
142
143
144
145

//! The model builder core: walks the tree-sitter tree, dispatching each node
//! to the scope / write / read handler groups, and records what it sees.

use std::collections::HashMap;

use tree_sitter::Node;

use super::{Entry, ScopeData, ScopeId, ScopeKind, Write};

pub(super) struct Builder<'m> {
    pub(super) src: &'m [u8],
    pub(super) scopes: &'m mut Vec<ScopeData>,
    pub(super) csend_sites: &'m mut Vec<(usize, Box<str>, ScopeId)>,
    pub(super) vcall_sites: &'m mut Vec<usize>,
}

impl<'m> Builder<'m> {
    pub(super) fn text<'t>(&'t self, n: Node<'t>) -> &'t str {
        n.utf8_text(self.src).unwrap_or("")
    }

    pub(super) fn scope_for(
        &mut self,
        owner: Node,
        kind: ScopeKind,
        parent: Option<ScopeId>,
    ) -> ScopeId {
        self.scopes.push(ScopeData {
            parent,
            kind,
            entered_at: owner.start_byte(),
            entries: HashMap::new(),
        });
        self.scopes.len() - 1
    }

    pub(super) fn lookup(&self, scope: ScopeId, pos: usize, name: &str) -> Option<ScopeId> {
        super::lookup_scope(self.scopes, scope, pos, name)
    }

    /// Record a write; creates the binding if not visible yet.
    pub(super) fn record_write(
        &mut self,
        scope: ScopeId,
        name: &str,
        w: Write,
        intro_kind: super::IntroKind,
    ) {
        if name.starts_with('_') {
            return;
        }
        let pos = w.byte;
        match self.lookup(scope, pos, name) {
            Some(s) => {
                self.scopes[s].entries.get_mut(name).unwrap().writes.push(w);
            }
            None => {
                let e = Entry {
                    intro_byte: pos,
                    intro_kind,
                    writes: vec![w],
                    reads: Vec::new(),
                };
                self.scopes[scope].entries.insert(name.into(), e);
            }
        }
    }

    pub(super) fn record_read(&mut self, scope: ScopeId, name: &str, r: super::Read) {
        let Some(s) = self.lookup(scope, r.byte, name) else {
            return;
        };

        self.scopes[s].entries.get_mut(name).unwrap().reads.push(r);
    }

    /// Bind a parameter-style entry only when no binding exists yet.
    pub(super) fn bind_entry(&mut self, scope: ScopeId, name: String, pos: usize) {
        self.scopes[scope]
            .entries
            .entry(name.into())
            .or_insert(Entry {
                intro_byte: pos,
                intro_kind: super::IntroKind::Binding,
                writes: Vec::new(),
                reads: Vec::new(),
            });
    }

    pub(super) fn walk(&mut self, n: Node, scope: ScopeId, under_defined: bool) {
        let kind = n.kind();
        if self.walk_scope_intro(n, kind, scope) {
            return;
        }
        if self.walk_write(n, kind, scope, under_defined) {
            return;
        }
        if self.walk_read(n, kind, scope, under_defined) {
            return;
        }
        self.walk_children(n, scope, under_defined);
    }

    /// Generic descent.
    fn walk_children(&mut self, n: Node, scope: ScopeId, under_defined: bool) {
        for child in n.children(&mut n.walk()) {
            if child.kind() == "method_parameters"
                || child.kind() == "block_parameters"
                || child.kind() == "lambda_parameters"
            {
                // stray parameter container outside a callable; descend into
                // default-value expressions only
                let mut sub = child.walk();
                for inner in child.children(&mut sub) {
                    if inner.child_by_field_name("value").is_some() {
                        self.walk(inner, scope, under_defined);
                    }
                }
                continue;
            }
            self.walk(child, scope, under_defined);
        }
    }
}

pub(super) fn declared_name(child: Node, src: &[u8]) -> Option<String> {
    match child.kind() {
        "identifier" => Some(child.utf8_text(src).unwrap_or("").to_string()),
        "optional_parameter" | "keyword_parameter" | "block_parameter" | "splat_parameter" => child
            .child_by_field_name("name")
            .or_else(|| {
                child
                    .children(&mut child.walk())
                    .find(|c| c.kind() == "identifier")
            })
            .map(|n| n.utf8_text(src).unwrap_or("").to_string()),
        _ => None,
    }
}

/// Body of a block-ish node regardless of brace/do form.
pub(super) fn body_of(n: Node) -> Option<Node> {
    n.children(&mut n.walk())
        .find(|c| c.kind() == "body_statement" || c.kind() == "block_body")
}