borrowscope-runtime 0.1.2

Runtime tracking system for BorrowScope
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212

//! Expression tracking: index, field access, calls, operators

use super::TRACKER;

pub fn track_index_access(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] access_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] container: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_index_access(access_id, container, location);
    }
}

/// Track field access
#[inline(always)]
pub fn track_field_access(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] access_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] base: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] field: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_field_access(access_id, base, field, location);
    }
}

/// Track function call
#[inline(always)]
pub fn track_call(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] call_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] fn_name: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_call(call_id, fn_name, location);
    }
}

/// Track lock acquisition (Mutex/RwLock)
#[inline(always)]
pub fn track_lock(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] lock_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] lock_type: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] var_name: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_lock(lock_id, lock_type, var_name, location);
    }
}

/// Track unwrap call (Option/Result)
#[inline(always)]
pub fn track_unwrap(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] unwrap_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] method: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] var_name: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_unwrap(unwrap_id, method, var_name, location);
    }
}

/// Track clone call
#[inline(always)]
pub fn track_clone(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] clone_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] var_name: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_clone(clone_id, var_name, location);
    }
}

/// Track dereference operation
#[inline(always)]
pub fn track_deref(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] deref_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] var_name: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_deref(deref_id, var_name, location);
    }
}

pub fn track_closure_create(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] closure_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] capture_mode: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_closure_create(closure_id, capture_mode, location);
    }
}

/// Track struct creation
#[inline(always)]
pub fn track_struct_create(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] struct_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] struct_name: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_struct_create(struct_id, struct_name, location);
    }
}

/// Track tuple creation
#[inline(always)]
pub fn track_tuple_create(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] tuple_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] arity: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_tuple_create(tuple_id, arity, location);
    }
}

/// Track let-else divergence
#[inline(always)]
pub fn track_let_else(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] let_else_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] pattern: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_let_else(let_else_id, pattern, location);
    }
}

/// Track range expression
#[inline(always)]
pub fn track_range(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] range_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] range_type: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_range(range_id, range_type, location);
    }
}

/// Track binary operation
#[inline(always)]
pub fn track_binary_op(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] op_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] operator: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_binary_op(op_id, operator, location);
    }
}

/// Track array creation
#[inline(always)]
pub fn track_array_create(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] array_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] length: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_array_create(array_id, length, location);
    }
}

/// Track type cast
#[inline(always)]
pub fn track_type_cast(
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] cast_id: usize,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] target_type: &str,
    #[cfg_attr(not(feature = "track"), allow(unused_variables))] location: &str,
) {
    #[cfg(feature = "track")]
    {
        let mut tracker = TRACKER.lock();
        tracker.record_type_cast(cast_id, target_type, location);
    }
}