captures 0.1.0

Provides macros to express more powerful closure captures
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

//! Our macro expands to something vaguely like this:
//!
//! ```text
//! {
//!     
//!     let x = x.clone(), // for `mut clone x`
//!     let y = &mut y, // for `ref mut y`
//!     let z = &z, // for `mut ref z`
//!     let w = expr, // for `with w = expr`
//!
//!     |old_sig| { // Keep the old closure signature
//!         let _ = &b; // for `all b`
//!         old_body // old closure body
//!     }
//! }
//! ```

use proc_macro2::{Ident, Punct, Spacing, TokenStream};
use quote::{quote, quote_spanned, ToTokens};

use crate::parse::*;

pub struct Changes {
    pub exterior: TokenStream,
    pub interior: TokenStream,
    pub exempt: Vec<Ident>,
}

impl Changes {
    pub fn from_input(input: &Input, only: bool) -> Changes {
        let mut exempt = Vec::new();
        let mut ext = TokenStream::new();
        let mut int = TokenStream::new();

        for d in &input.assigned {
            let mu = &d.mu;
            let mut int_upvar = d.upvar.clone();
            if only {
                make_mixed!(int_upvar);
            }
            ext.extend(quote!(let #mu #int_upvar = ));
            match &d.ty {
                DirectiveType::Clone(sp) => {
                    let sp = *sp;
                    let ext_upvar = &d.upvar;
                    ext.extend(quote_spanned![sp=> ::core::clone::Clone::clone(&#ext_upvar)]);
                }
                DirectiveType::With(expr) => {
                    (&expr).to_tokens(&mut ext);
                }
                DirectiveType::Ref(sp, mu) => {
                    let mut ref_punc = Punct::new('&', Spacing::Alone);
                    ref_punc.set_span(*sp);
                    let ext_upvar = &d.upvar;
                    ext.extend(quote!(#ref_punc #mu #ext_upvar));
                }
            }
            ext.extend(quote!(;));
        }

        for d in &input.all {
            let upvar = &d.upvar;
            exempt.push(upvar.clone());
            int.extend(quote!(let _ = &#upvar;));
        }

        Changes {
            exterior: ext,
            interior: int,
            exempt,
        }
    }
}