Add library support for destructible lambdas

Author: lucic71

libcc2rs-macros/src/lambda.rs

@@ -18,6 +18,7 @@ struct Lambda {
     closure: ExprClosure,
     copy_from: Option<CaptureInits>,
     move_from: Option<CaptureInits>,
+    destroy: Option<proc_macro2::TokenStream>,
 }
 
 impl Parse for Lambda {
@@ -28,19 +29,24 @@ impl Parse for Lambda {
         input.parse::<Option<Token![,]>>()?;
         let mut copy_from = None;
         let mut move_from = None;
+        let mut destroy = None;
         while !input.is_empty() {
             let name: Ident = input.parse()?;
-            let inits;
-            braced!(inits in input);
-            let inits = inits.parse_terminated(FieldValue::parse, Token![,])?;
+            if name == "destroy" {
+                input.parse::<Token![=]>()?;
+            }
+            let body;
+            braced!(body in input);
             if name == "copy_from" {
-                copy_from = Some(inits);
+                copy_from = Some(body.parse_terminated(FieldValue::parse, Token![,])?);
             } else if name == "move_from" {
-                move_from = Some(inits);
+                move_from = Some(body.parse_terminated(FieldValue::parse, Token![,])?);
+            } else if name == "destroy" {
+                destroy = Some(body.parse()?);
             } else {
                 return Err(Error::new(
                     name.span(),
-                    "expected `copy_from` or `move_from`",
+                    "expected `copy_from`, `move_from` or `destroy`",
                 ));
             }
             input.parse::<Option<Token![,]>>()?;
@@ -50,6 +56,7 @@ impl Parse for Lambda {
             closure,
             copy_from,
             move_from,
+            destroy,
         })
     }
 }
@@ -207,14 +214,21 @@ fn expand_lambda(lambda: Lambda, is_unsafe: bool) -> Result<proc_macro2::TokenSt
     let body = rewrite_captures(quote! { #body }, &captured, false)?;
     let copy_from = expand_constructor(&lambda.copy_from, &captured, is_unsafe)?;
     let move_from = expand_constructor(&lambda.move_from, &captured, is_unsafe)?;
-    let (receiver, body, constructor) = if is_unsafe {
+    let destroy = &lambda.destroy;
+    let (receiver, body, destroy, constructor) = if is_unsafe {
         (
             quote! { &mut self },
             quote! { unsafe { #body } },
+            quote! { unsafe { #destroy } },
             quote! { from_lambda_unsafe },
         )
     } else {
-        (quote! { &self }, body, quote! { from_lambda })
+        (
+            quote! { &self },
+            body,
+            quote! { #destroy },
+            quote! { from_lambda },
+        )
     };
 
     Ok(quote! {{
@@ -234,12 +248,17 @@ fn expand_lambda(lambda: Lambda, is_unsafe: bool) -> Result<proc_macro2::TokenSt
             fn move_from(#receiver) -> Self {
                 #move_from
             }
+            #[allow(unused_unsafe)]
+            fn destroy(#receiver) {
+                #destroy
+            }
         }
         ::libcc2rs::FnPtr::<fn(#(#param_types),*) #output>::#constructor(
             __Lambda { #(#names: #inits,)* },
             __Lambda::call,
             __Lambda::copy_from,
             __Lambda::move_from,
+            __Lambda::destroy,
         )
     }})
 }

libcc2rs/src/fn_ptr.rs

@@ -58,6 +58,8 @@ trait Adapted: Any {
     fn move_from(&self) -> Option<Rc<dyn Adapted>> {
         None
     }
+
+    fn destroy(&self) {}
 }
 
 impl<T: FnSig> Adapted for T {
@@ -72,20 +74,23 @@ trait Lambda<T: FnSig> {
     fn call(&self, args: T::Args) -> T::Ret;
     fn copy_from(&self) -> Box<dyn Lambda<T>>;
     fn move_from(&self) -> Box<dyn Lambda<T>>;
+    fn destroy(&self);
 }
 
 struct LambdaSafe<L, C> {
     captures: L,
     call: C,
     copy_from: fn(&L) -> L,
     move_from: fn(&L) -> L,
+    destroy: fn(&L),
 }
 
 struct LambdaUnsafe<L, C> {
     captures: UnsafeCell<L>,
     call: C,
     copy_from: fn(&mut L) -> L,
     move_from: fn(&mut L) -> L,
+    destroy: fn(&mut L),
 }
 
 struct Closure<T: FnSig>(Box<dyn Lambda<T>>);
@@ -104,6 +109,10 @@ impl<T: FnSig> Adapted for Closure<T> {
     fn move_from(&self) -> Option<Rc<dyn Adapted>> {
         Some(Rc::new(Closure::<T>(self.0.move_from())))
     }
+
+    fn destroy(&self) {
+        self.0.destroy();
+    }
 }
 
 pub struct FnPtr<T: FnSig> {
@@ -225,6 +234,12 @@ impl<T: FnSig> FnPtr<T> {
         }
     }
 
+    pub fn destroy(&self) {
+        if let Some(original) = &self.original {
+            original.destroy();
+        }
+    }
+
     fn boxed_original(&self) -> Option<Rc<dyn Adapted>> {
         match &self.original {
             Some(original) => Some(original.clone()),
@@ -254,8 +269,9 @@ macro_rules! impl_fn_ptr_call {
                 call: fn(&Captures $(, $a)*) -> R,
                 copy_from: fn(&Captures) -> Captures,
                 move_from: fn(&Captures) -> Captures,
+                destroy: fn(&Captures),
             ) -> Self {
-                let lambda = LambdaSafe { captures, call, copy_from, move_from };
+                let lambda = LambdaSafe { captures, call, copy_from, move_from, destroy };
                 FnPtr {
                     addr: call as usize,
                     current: None,
@@ -268,12 +284,14 @@ macro_rules! impl_fn_ptr_call {
                 call: fn(&mut Captures $(, $a)*) -> R,
                 copy_from: fn(&mut Captures) -> Captures,
                 move_from: fn(&mut Captures) -> Captures,
+                destroy: fn(&mut Captures),
             ) -> Self {
                 let lambda = LambdaUnsafe {
                     captures: UnsafeCell::new(captures),
                     call,
                     copy_from,
                     move_from,
+                    destroy,
                 };
                 FnPtr {
                     addr: call as usize,
@@ -297,6 +315,7 @@ macro_rules! impl_fn_ptr_call {
                     call: self.call,
                     copy_from: self.copy_from,
                     move_from: self.move_from,
+                    destroy: self.destroy,
                 })
             }
 
@@ -306,8 +325,13 @@ macro_rules! impl_fn_ptr_call {
                     call: self.call,
                     copy_from: self.copy_from,
                     move_from: self.move_from,
+                    destroy: self.destroy,
                 })
             }
+
+            fn destroy(&self) {
+                (self.destroy)(&self.captures)
+            }
         }
 
         impl<Captures: 'static, R: FnPtrArg $(, $a: FnPtrArg)*> Lambda<fn($($a,)*) -> R>
@@ -326,6 +350,7 @@ macro_rules! impl_fn_ptr_call {
                     call: self.call,
                     copy_from: self.copy_from,
                     move_from: self.move_from,
+                    destroy: self.destroy,
                 })
             }
 
@@ -337,8 +362,13 @@ macro_rules! impl_fn_ptr_call {
                     call: self.call,
                     copy_from: self.copy_from,
                     move_from: self.move_from,
+                    destroy: self.destroy,
                 })
             }
+
+            fn destroy(&self) {
+                (self.destroy)(unsafe { &mut *self.captures.get() })
+            }
         }
         impl_fn_ptr_call!(@peel $($a)*);
     };