borrowscope-macro 0.1.1

Procedural macros for BorrowScope ownership tracking
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

//! Code generation utilities

#![allow(dead_code)]

use quote::quote;
use syn::{Expr, Ident};

/// Generate optimized tracking call for new variables
pub fn generate_track_new(var_name: &Ident, init_expr: &Expr) -> proc_macro2::TokenStream {
    quote! {
        borrowscope_runtime::track_new(stringify!(#var_name), #init_expr)
    }
}

/// Generate optimized borrow tracking
pub fn generate_track_borrow(
    var_name: &Ident,
    borrowed_expr: &Expr,
    is_mutable: bool,
) -> proc_macro2::TokenStream {
    if is_mutable {
        quote! {
            borrowscope_runtime::track_borrow_mut(stringify!(#var_name), #borrowed_expr)
        }
    } else {
        quote! {
            borrowscope_runtime::track_borrow(stringify!(#var_name), #borrowed_expr)
        }
    }
}

/// Generate drop calls with proper ordering (LIFO)
pub fn generate_drop_calls(variables: &[Ident]) -> proc_macro2::TokenStream {
    let reversed: Vec<_> = variables.iter().rev().collect();

    quote! {
        #(
            borrowscope_runtime::track_drop(stringify!(#reversed));
        )*
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use syn::parse_quote;

    #[test]
    fn test_generate_track_new() {
        let var: Ident = parse_quote!(x);
        let expr: Expr = parse_quote!(5);

        let code = generate_track_new(&var, &expr);
        let result = code.to_string();

        assert!(result.contains("track_new"));
        assert!(result.contains("stringify"));
        assert!(result.contains("x"));
    }

    #[test]
    fn test_generate_track_borrow_immutable() {
        let var: Ident = parse_quote!(y);
        let expr: Expr = parse_quote!(x);

        let code = generate_track_borrow(&var, &expr, false);
        let result = code.to_string();

        assert!(result.contains("track_borrow"));
        assert!(!result.contains("track_borrow_mut"));
    }

    #[test]
    fn test_generate_track_borrow_mutable() {
        let var: Ident = parse_quote!(y);
        let expr: Expr = parse_quote!(x);

        let code = generate_track_borrow(&var, &expr, true);
        let result = code.to_string();

        assert!(result.contains("track_borrow_mut"));
    }

    #[test]
    fn test_generate_drop_calls_order() {
        let vars = vec![parse_quote!(x), parse_quote!(y), parse_quote!(z)];

        let code = generate_drop_calls(&vars);
        let result = code.to_string();

        // Variables should be in reverse order (LIFO: z, y, x)
        // The generated code contains stringify! calls
        assert!(result.contains("z"));
        assert!(result.contains("y"));
        assert!(result.contains("x"));
    }

    #[test]
    fn test_generate_drop_calls_empty() {
        let vars: Vec<Ident> = vec![];
        let code = generate_drop_calls(&vars);
        let result = code.to_string();

        assert!(result.is_empty() || result.trim().is_empty());
    }
}