abcop 0.16.4

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

//! End-to-end assertions over the Java backend: AbcSize vectors,
//! UsedOnce candidacy and NeverUsed reporting.

use super::{build, never_used_offenses, used_once_offenses};
use crate::abc::parse_vector;
use crate::paths::{Lang, parse_file_lang};

fn parse(src: &'static str) -> crate::javalang::JavaFile<'static> {
    let tree = parse_file_lang(src.as_bytes(), Lang::Java).expect("java parses");
    build(src.as_bytes(), tree)
}

fn scores(src: &'static str) -> Vec<(String, u32, u32, u32)> {
    super::abc::all_scores(&parse(src))
        .into_iter()
        .map(|o| {
            let (a, b, c) = parse_vector(&o.vector);
            (o.name, a, b, c)
        })
        .collect()
}

fn used(src: &'static str) -> Vec<String> {
    let fm = parse(src);
    let mut v: Vec<_> = used_once_offenses(&fm)
        .into_iter()
        .map(|o| o.name)
        .collect();
    v.sort();
    v
}

fn dead(src: &'static str) -> Vec<String> {
    let fm = parse(src);
    let mut v: Vec<_> = never_used_offenses(&fm)
        .into_iter()
        .map(|o| o.name)
        .collect();
    v.sort();
    v
}

#[test]
fn assignment_and_binary_count_as_a_and_b() {
    assert_eq!(
        scores("class K {\n  int simple(int a) {\n    int x = a + 1;\n    return x;\n  }\n}"),
        vec![("simple".to_string(), 1, 1, 0)]
    );
}

#[test]
fn branches_loops_switch_labels_tally_c() {
    // A: total, it(head), += ; B: two length() invocations
    // C: enhanced-for, if, ==, ||, >, elseif-if, <, switch label x2
    let src = "class K {\n  int run(java.util.List<String> items, int limit) {\n\
               \x20   int total = 0;\n\
               \x20   for (String it : items) {\n\
               \x20     if (it == null || it.length() > limit) continue;\n\
               \x20     else if (total < 0) break;\n\
               \x20     total += it.length();\n\
               \x20   }\n\
               \x20   switch (total) { case 0 -> total++; default -> total--; }\n\
               \x20   return total;\n\
               \x20 }\n}";
    assert_eq!(scores(src), vec![("run".to_string(), 5, 2, 9)]);
}

#[test]
fn constructors_are_units_and_lambdas_roll_in() {
    let got = scores(
        "class K {\n  int seed;\n  K(int seed) {\n\
                     \x20   this.seed = seed;\n\
                     \x20   java.util.function.IntSupplier s = () -> 40 + 2;\n\
                     \x20   useLater(s);\n\
                     \x20 }\n}",
    );
    assert_eq!(got.len(), 1);
    // A: the local `s` declarator (field target binds nothing)
    // B: + inside the lambda and the useLater(...) invocation
    assert_eq!(got[0], ("K".to_string(), 1, 2, 0));
}

#[test]
fn member_names_are_not_variable_reads() {
    let src =
        "class K {\n  int m(K other) {\n    other.count = 1;\n    return other.count;\n  }\n}";
    // A: 0 (field targets bind nothing); B: none beyond assignments? the
    // two field accesses are reads of `other` only; assignments to fields
    // contribute no A. C: 0.
    assert_eq!(
        dead(src),
        Vec::<String>::new(),
        "field writes are not local bindings"
    );
}

#[test]
fn used_once_flags_single_pure_straightline_binding() {
    assert_eq!(
        used("class K {\n  int ok(int f) {\n    int x = 42;\n    return x + f;\n  }\n}"),
        vec!["x"]
    );
}

#[test]
fn used_once_rejections() {
    let src = "class K {\n  int rej(boolean f) {\n\
               \x20   int a = id();\n\
               \x20   int b = 1; b = 2;\n\
               \x20   int c = 1; c += 1;\n\
               \x20   if (f) { int e = 1; }\n\
               \x20   return a;\n\
               \x20 }\n}";
    assert_eq!(used(src), Vec::<String>::new());
}

#[test]
fn never_used_reports_dead_writes_once() {
    let src = "class K {\n  int dd() {\n    int unused = 1;\n    return 0;\n  }\n}";
    assert_eq!(dead(src), vec!["unused"]);
}

#[test]
fn protocol_bindings_are_exempt() {
    let src = "class K {\n  void proto(java.util.List<Integer> items) {\n\
               \x20   for (int i = 0; i < items.size(); i++) { System.out.println(items); }\n\
               \x20   try (var res = open()) { res.toString(); }\n\
               \x20   catch (RuntimeException ex) { }\n\
               \x20 }\n}";
    assert_eq!(dead(src), vec!["ex"]);
}