Implements heap de-allocation

macros/src/cpp.rs

@@ -176,6 +176,10 @@ fn render_class(item: Class) -> syn::Result<TokenStream> {
             fn alloc() -> *mut () {
                 unsafe { ::cppbind::new(#size) }
             }
+
+            unsafe fn dealloc(this: *mut ()) {
+                ::cppbind::delete(this, #size);
+            }
         }
 
         impl ::cppbind::Memory for &mut #mem {

macros/src/symbol.rs

@@ -45,6 +45,7 @@ impl<'a> Symbol<'a> {
                 Segment::Ctor => n.push_str("C1"),
                 Segment::Dtor => n.push_str("D1"),
                 Segment::New => n.push_str("nw"),
+                Segment::Delete => n.push_str("dl"),
             }
         };
 
@@ -62,12 +63,17 @@ impl<'a> Symbol<'a> {
         }
 
         // Build signature.
+        fn push_type(n: &mut String, t: &Type) {
+            match t {
+                Type::Void => n.push('v'),
+                Type::Ulong => n.push('m'),
+                Type::Ptr(v) => push_type(n, &v),
+            }
+        }
+
         if let Some(s) = &self.sig {
             for p in &s.params {
-                match p {
-                    Type::Void => name.push('v'),
-                    Type::Ulong => name.push('m'),
-                }
+                push_type(&mut name, p);
             }
         }
 
@@ -90,6 +96,7 @@ pub enum Segment<'a> {
     Ctor,
     Dtor,
     New,
+    Delete,
 }
 
 /// Argument of a template instantiation.
@@ -115,6 +122,7 @@ impl Signature {
 pub enum Type {
     Void,
     Ulong,
+    Ptr(Box<Self>),
 }
 
 /// Represents an error when [`Symbol`] fails to parse from a mangled name.

src/ffi.rs

@@ -1,4 +1,6 @@
 unsafe extern "C-unwind" {
     #[link_name = "\u{1}_Znwm"]
     pub fn new(len: usize) -> *mut ();
+    #[link_name = "\u{1}_ZdlPvm"]
+    pub fn delete(ptr: *mut (), len: usize);
 }

src/lib.rs

@@ -4,14 +4,20 @@ pub use cppbind_macros::*;
 mod ffi;
 
 /// Memory of a C++ class that live on a heap.
-pub struct Heap<T>(*mut T);
+pub struct Heap<T: HeapAlloc>(*mut T);
 
 impl<T: HeapAlloc> Heap<T> {
     pub fn new() -> Self {
         Self(T::alloc().cast())
     }
 }
 
+impl<T: HeapAlloc> Drop for Heap<T> {
+    fn drop(&mut self) {
+        unsafe { T::dealloc(self.0.cast()) };
+    }
+}
+
 impl<T: HeapAlloc> Memory for Heap<T> {
     type Class = T::Class;
 
@@ -20,8 +26,8 @@ impl<T: HeapAlloc> Memory for Heap<T> {
     }
 }
 
-unsafe impl<T: Send> Send for Heap<T> {}
-unsafe impl<T: Sync> Sync for Heap<T> {}
+unsafe impl<T: HeapAlloc + Send> Send for Heap<T> {}
+unsafe impl<T: HeapAlloc + Sync> Sync for Heap<T> {}
 
 /// Memory of a C++ class.
 pub trait Memory {
@@ -35,4 +41,5 @@ pub trait HeapAlloc {
     type Class;
 
     fn alloc() -> *mut ();
+    unsafe fn dealloc(this: *mut ());
 }