hyperast 0.2.0

Temporal code analyses at scale
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
120
121
122
123
124
125
126

use super::*;

pub fn compute_byte_len_aux<'r>(e: EntityRef<'r>) -> Result<usize, &'r [Entity]> {
    let r = match (e.get::<Lab>(), e.get::<Children>()) {
        (None, None) => e.get::<Type>().unwrap().0.as_bytes().len(),
        (Some(Lab(l)), None) => l.as_bytes().len(),
        (_, Some(Children(cs))) => return Err(cs),
    };
    Ok(r)
}


pub fn compute_rec_byte_len(w: &World, e: EntityRef) -> ByteLen {
    let r = match compute_byte_len_aux(e) {
        Ok(r) => r,
        Err(cs) => cs
            .iter()
            .map(|x| compute_rec_byte_len(w, w.entity(*x)).to_usize())
            .sum(),
    };
    ByteLen(r)
}

#[test]
fn test_compute_byte_len() {
    let mut world = World::new();

    // construction
    let l_42 = world.spawn(Leaf {
        ty: Type("number"),
        label: Lab("42"),
    });
    let l_42 = l_42.id();
    let op_plus = world.spawn(Type("+"));
    let op_plus = op_plus.id();
    let l_x = world.spawn(Leaf {
        ty: Type("identifier"),
        label: Lab("x"),
    });
    let l_x = l_x.id();
    let expr_bin = world.spawn(Node {
        ty: Type("binary_expr"),
        cs: Children(vec![l_42, op_plus, l_x].into()),
    });
    let expr_bin = expr_bin.id();

    // usage
    assert_eq!(ByteLen(4), compute_rec_byte_len(&world, world.entity(expr_bin)));
}


pub fn precompute_byte_len(w: &World, e: EntityRef) -> ByteLen {
    let r = match compute_byte_len_aux(e) {
        Ok(r) => r,
        Err(cs) => w
            .get_many_entities_dynamic(&cs)
            .expect("should all be there")
            .iter()
            .map(|x| x.get::<ByteLen>().unwrap().to_usize())
            .sum(),
    };
    ByteLen(r)
}

#[test]
fn test_precompute_byte_len() {
    // Create a new empty World to hold our Entities and Components
    let mut world = World::new();

    // construction
    let mut l_42 = world.spawn(Leaf {
        ty: Type("number"),
        label: Lab("42"),
    });
    precompute_md(&mut l_42, precompute_byte_len);
    let l_42 = l_42.id();
    let mut op_plus = world.spawn(Type("+"));
    precompute_md(&mut op_plus, precompute_byte_len);
    let op_plus = op_plus.id();
    let mut l_x = world.spawn(Leaf {
        ty: Type("identifier"),
        label: Lab("x"),
    });
    precompute_md(&mut l_x, precompute_byte_len);
    let l_x = l_x.id();
    let mut expr_bin = world.spawn(Node {
        ty: Type("binary_expr"),
        cs: Children(vec![l_42, op_plus, l_x].into()),
    });
    precompute_md(&mut expr_bin, precompute_byte_len);
    let expr_bin = expr_bin.id();

    // usage
    assert_eq!(Some(&ByteLen(4)), world.entity(expr_bin).get::<ByteLen>());
}

// WIP

pub fn compute_hybr_byte_len(w: &World, e: EntityRef) -> ByteLen {
    let r = match compute_byte_len_aux(e) {
        Ok(r) => r,
        Err(cs) => w
            .get_many_entities_dynamic(&cs)
            .expect("should all be there")
            .iter()
            .map(|x| {
                x.get::<ByteLen>()
                    .map_or_else(|| compute_rec_byte_len(w, *x).to_usize(), |x| x.to_usize())
            })
            .sum(),
    };
    ByteLen(r)
}

pub fn compute_hybrec_byte_len(w: &World, e: EntityRef) -> ByteLen {
    let r = match compute_byte_len_aux(e) {
        Ok(r) => r,
        Err(cs) => w
            .get_many_entities_dynamic(&cs)
            .expect("should all be there")
            .iter()
            .map(|x| compute_hybr_byte_len(w, *x).to_usize())
            .sum(),
    };
    ByteLen(r)
}