abcop 0.17.2

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

//! Per-file analysis pipeline: scope resolution feeding the backend
//! dispatch (`backends`), cache round-trip, and changeset narrowing
//! (`narrow`).

use crate::abc::Limits;
use crate::cache;
use crate::git_changes;
use crate::paths::{Lang, lang_for, parse_file_lang};
use crate::srcbuf::{SrcBuf, load_src};
mod backends;
mod narrow;
mod non_clike;

#[cfg(test)]
mod tests;
#[cfg(test)]
mod tests_fs;

#[derive(Debug)]
pub(crate) struct Checks {
    pub want_abc: bool,
    pub want_used: bool,
    pub want_never: bool,
}

impl Checks {
    pub fn new(only: Option<&str>) -> Self {
        Self {
            want_abc: only.is_none_or(|o| o == "abc"),
            want_used: only.is_none_or(|o| o == "used-once"),
            want_never: only.is_none_or(|o| o == "never-used"),
        }
    }
}

fn blank_with(path: &std::path::Path) -> crate::output::FileResult {
    crate::output::FileResult {
        path: path.display().to_string(),
        abc: Vec::new(),
        used_once: Vec::new(),
        never_used: Vec::new(),
        module_abc: None,
    }
}

fn reparsed<'a>(src_bytes: &'a [u8], lang: Lang) -> Option<crate::model::FileModel<'a>> {
    let tree = parse_file_lang(src_bytes, lang)?;
    Some(crate::model::build(src_bytes, tree))
}

pub(crate) fn analyze_one(
    path: &std::path::Path,
    only: Option<&str>,
    limits: Limits,
    changeset: Option<&git_changes::Changeset>,
    cache: Option<&cache::Cache>,
) -> crate::output::FileResult {
    let Some((mut r, src_buf)) = loaded_result(path) else {
        return blank_with(path);
    };
    // Cache stores raw per-file results; scope narrowing is per-run and
    // must also apply when the analysis itself comes from the cache.
    let hit = cache.and_then(|c| cache_hit(c, path, &src_buf, only, limits));
    if let Some(mut hit) = hit {
        narrow::apply(changeset, &mut hit, limits.module, &src_buf);
        return hit;
    }

    let file_lang = lang_for(path);
    let Some(tree) = parse_file_lang(&src_buf, file_lang) else {
        return r;
    };
    let checks = Checks::new(only);
    if file_lang.is_clike() {
        backends::clike_arm(&mut r, file_lang, &src_buf, &tree, &checks, limits);
    } else if !backends::non_clike_arm(&mut r, file_lang, &src_buf, tree, &checks, limits) {
        // Unparsable Ruby tree: report the blank result without caching it.
        return r;
    }
    store_result(cache, path, &src_buf, only, limits, &r);
    narrow::apply(changeset, &mut r, limits.module, &src_buf);
    r
}

/// Blank result plus source bytes; None when the file cannot be read.
fn loaded_result(path: &std::path::Path) -> Option<(crate::output::FileResult, SrcBuf)> {
    let r = blank_with(path);
    let src_buf = load_src(path).ok()?;
    Some((r, src_buf))
}

/// Cached FileResult rebuilt from the store; None on a miss.
fn cache_hit(
    cache: &cache::Cache,
    path: &std::path::Path,
    src: &[u8],
    only: Option<&str>,
    limits: Limits,
) -> Option<crate::output::FileResult> {
    let (abc, used_once, never_used, module_abc) =
        cache.get(&cache.file_key(path, src, only, limits))?;
    Some(crate::output::FileResult {
        path: path.display().to_string(),
        abc,
        used_once,
        never_used,
        module_abc,
    })
}

fn store_result(
    cache: Option<&cache::Cache>,
    path: &std::path::Path,
    src: &[u8],
    only: Option<&str>,
    limits: Limits,
    r: &crate::output::FileResult,
) {
    if let Some(cache) = cache {
        cache.store(
            &cache.file_key(path, src, only, limits),
            &r.abc,
            &r.used_once,
            &r.never_used,
            r.module_abc.clone(),
        );
    }
}