pass by ref done

deno_bindgen_ir/codegen/deno.rs

@@ -25,6 +25,7 @@ impl TypeScriptType<'_> {
       Self("Uint8Array", false) => {
         Cow::Owned(format!("{ident},\n    {ident}.byteLength"))
       }
+      Self(_, true) => Cow::Owned(format!("{ident}.ptr")),
       _ => Cow::Borrowed(ident),
     }
   }
@@ -48,7 +49,7 @@ impl TypeScriptType<'_> {
 impl From<Type> for TypeScriptType<'_> {
   fn from(value: Type) -> Self {
     Self(
-      (match value {
+      match value {
         Type::Void => "void",
         Type::Uint8
         | Type::Uint16
@@ -63,7 +64,7 @@ impl From<Type> for TypeScriptType<'_> {
         Type::Pointer => "Deno.PointerObject | null",
         Type::Buffer => "Uint8Array",
         Type::CustomType(name) => name,
-      }),
+      },
       matches!(value, Type::CustomType(_)),
     )
   }
@@ -256,11 +257,7 @@ impl<'a> Codegen<'a> {
           }
           writeln!(writer, "\n}}\n")?;
         }
-        Inventory::Struct(Struct {
-          name,
-          methods,
-          constructor,
-        }) => {
+        Inventory::Struct(Struct { name, methods }) => {
           write!(writer, "export class {name} ")?;
 
           format_paren(
@@ -270,6 +267,7 @@ impl<'a> Codegen<'a> {
             |writer, methods| {
               writeln!(writer, "  ptr: Deno.PointerObject | null = null;\n")?;
 
+              // Internal constructor.
               writeln!(
                 writer,
                 "  static __constructor(ptr: Deno.PointerObject | null) {{"
@@ -280,6 +278,12 @@ impl<'a> Codegen<'a> {
               )?;
               writeln!(writer, "    self.ptr = ptr;")?;
               writeln!(writer, "    return self;")?;
+              writeln!(writer, "  }}\n")?;
+
+              // Dispose method (explicit resource management)
+              writeln!(writer, "  [Symbol.dispose]() {{")?;
+              writeln!(writer, "    this.dealloc();")?;
+              writeln!(writer, "    this.ptr = null;")?;
               writeln!(writer, "  }}")?;
 
               for method in methods {

deno_bindgen_ir/inventory.rs

@@ -3,7 +3,6 @@ use crate::Symbol;
 #[derive(Debug)]
 pub struct Struct {
   pub name: &'static str,
-  pub constructor: Option<Symbol>,
   pub methods: &'static [Symbol],
 }
 

deno_bindgen_ir/lib.rs

@@ -63,6 +63,7 @@ impl Type {
       Self::CustomType(_) => {
         let pointer = &args[0];
         Some(quote! {
+          debug_assert!(!#pointer.is_null());
           let #name = unsafe { &mut *(#pointer as *mut _) };
         })
       }

deno_bindgen_macro/src/fn_.rs

@@ -13,6 +13,11 @@ use crate::{
   FnAttributes,
 };
 
+fn custom_type(ty: &str) -> Type {
+  // yeah, don't worry about it.
+  Type::CustomType(Box::leak(ty.to_string().into_boxed_str()))
+}
+
 fn parse_type(ty: &Box<syn::Type>) -> Result<Type> {
   match **ty {
     syn::Type::Path(TypePath { ref path, .. }) => {
@@ -31,10 +36,7 @@ fn parse_type(ty: &Box<syn::Type>) -> Result<Type> {
           "usize" => return Ok(Type::Uint64),
           "isize" => return Ok(Type::Int64),
           ty_str => {
-            return Ok(Type::CustomType(
-              // yeah, don't worry about it.
-              Box::leak(ty_str.to_string().into_boxed_str()),
-            ))
+            return Ok(custom_type(ty_str));
           }
         }
       }
@@ -48,6 +50,13 @@ fn parse_type(ty: &Box<syn::Type>) -> Result<Type> {
         }
       }
 
+      if let syn::Type::Path(TypePath { ref path, .. }) = *elem.as_ref() {
+        if let Some(ident) = path.get_ident() {
+          let ref ty_str = ident.to_string();
+          return Ok(custom_type(ty_str));
+        }
+      }
+
       Err(Error::UnsupportedType)
     }
 

deno_bindgen_macro/src/impl_.rs

@@ -1,6 +1,6 @@
 use proc_macro2::TokenStream as TokenStream2;
 use quote::format_ident;
-use syn::{parse, parse_quote, punctuated::Punctuated, ImplItemFn, ItemImpl};
+use syn::{parse_quote, punctuated::Punctuated, ImplItemFn, ItemImpl};
 
 use crate::util::{self, Result};
 
@@ -69,7 +69,7 @@ pub fn handle(mut impl_: ItemImpl) -> Result<TokenStream2> {
             }
           }
         } else if is_constructor {
-          let idents = idents_with_skip(inputs.clone(), 1);
+          let idents = idents_with_skip(inputs.clone(), 0);
           parse_quote!(
             #[allow(non_snake_case)]
             fn #mangled_name (#(#inputs),*) #out {
@@ -100,11 +100,31 @@ pub fn handle(mut impl_: ItemImpl) -> Result<TokenStream2> {
     }
   }
 
-  // TODO:
-  // - create a new quoted function for each method and codegen using fn_::handle
-  // where first arg is self ptr and rest are method args
-  // - constructor is a simply special case with no self ptr.
-  // - we also need to be aware of &mut self and Self types.
+  // Generate a dealloc method.
+  {
+    let ident = format_ident!("__{}_dealloc", ty_str);
+    let dispose = parse_quote! {
+      #[allow(non_snake_case)]
+      fn #ident(self_: *mut #ty_str) {
+        if self_.is_null() {
+          return;
+        }
+        unsafe { drop(Box::from_raw(self_)) }
+      }
+    };
+    let (generated, mut sym) = crate::fn_::handle_inner(
+      dispose,
+      crate::FnAttributes {
+        internal: true,
+        ..Default::default()
+      },
+    )?;
+
+    sym.set_name(format_ident!("dealloc"));
+
+    methods.push(generated);
+    syms.push(quote::quote! { #sym });
+  }
 
   Ok(quote::quote! {
     #impl_
@@ -118,7 +138,6 @@ pub fn handle(mut impl_: ItemImpl) -> Result<TokenStream2> {
       pub static _B: deno_bindgen::Inventory = deno_bindgen::Inventory::Struct(
         deno_bindgen::inventory::Struct {
           name: stringify!(#ty_str),
-          constructor: None,
           methods: &[#syms],
         }
       );

example/bindings/bindings.ts

@@ -60,12 +60,21 @@ const { symbols } = dlopen('./target/debug/libdeno_bindgen_test.dylib', {
     result: 'pointer',
     nonblocking: false
   },
+  inc_foo: {
+    parameters: [
+      'pointer',
+    ],
+    result: 'void',
+    nonblocking: false
+  },
   __Foo_new: {
-    parameters: [],
+    parameters: [
+      'u32',
+    ],
     result: 'pointer',
     nonblocking: false
   },
-  __Foo_foo: {
+  __Foo_inc: {
     parameters: [
       'pointer',
     ],
@@ -80,6 +89,13 @@ const { symbols } = dlopen('./target/debug/libdeno_bindgen_test.dylib', {
     result: 'u32',
     nonblocking: false
   },
+  __Foo_dealloc: {
+    parameters: [
+      'pointer',
+    ],
+    result: 'void',
+    nonblocking: false
+  },
 });
 
 export function add(
@@ -141,15 +157,27 @@ export function make_foo(): Foo {
   return Foo.__constructor(ret);
 }
 
-function __Foo_new(): Foo {
-  const ret = symbols.__Foo_new()
+export function inc_foo(
+  arg0: Foo,
+): void {
+  return symbols.inc_foo(
+    arg0.ptr,
+  )
+}
+
+function __Foo_new(
+  arg0: number,
+): Foo {
+  const ret = symbols.__Foo_new(
+    arg0,
+  )
   return Foo.__constructor(ret);
 }
 
-function __Foo_foo(
+function __Foo_inc(
   arg0: Deno.PointerObject | null,
 ): void {
-  return symbols.__Foo_foo(
+  return symbols.__Foo_inc(
     arg0,
   )
 }
@@ -164,6 +192,14 @@ function __Foo_bar(
   )
 }
 
+function __Foo_dealloc(
+  arg0: Deno.PointerObject | null,
+): void {
+  return symbols.__Foo_dealloc(
+    arg0,
+  )
+}
+
 export class Foo {
   ptr: Deno.PointerObject | null = null;
 
@@ -173,12 +209,19 @@ export class Foo {
     return self;
   }
 
-  constructor() {
-    return __Foo_new()
+  [Symbol.dispose]() {
+    this.dealloc();
+    this.ptr = null;
+  }
+
+  constructor(arg0: number) {
+    return __Foo_new(
+      arg0,
+    )
   }
 
-  foo(): void {
-    return __Foo_foo(
+  inc(): void {
+    return __Foo_inc(
       this.ptr,
     )
   }
@@ -189,4 +232,10 @@ export class Foo {
       arg0,
     )
   }
+
+  dealloc(): void {
+    return __Foo_dealloc(
+      this.ptr,
+    )
+  }
 }

example/bindings_test.ts

@@ -7,9 +7,10 @@ import {
   strlen,
   non_blocking,
   make_foo,
-  Foo,
+  inc_foo,
+  Foo,  
 } from "./bindings/bindings.ts";
-import { assert, assertEquals } from "https://deno.land/std/testing/asserts.ts";
+import { assert, assertEquals } from "https://deno.land/std@0.178.0/testing/asserts.ts";
 
 Deno.test({
   name: "add#test",
@@ -72,7 +73,36 @@ Deno.test({
 Deno.test({
   name: "Foo#constructor",
   fn() {
-    const foo = new Foo();
+    const foo = new Foo(42);
     assertEquals(foo.bar(1), 43);
   }
+})
+
+Deno.test({
+  name: "Foo#using",
+  fn() {
+    using foo = new Foo(1);
+    foo.inc();
+    assertEquals(foo.bar(1), 3);
+  }
+});
+
+Deno.test({
+  name: "Foo#using explicit",
+  fn() {
+    using foo = make_foo();
+
+    // Multiple dipose calls are nop.
+    foo[Symbol.dispose]();
+    foo[Symbol.dispose]();
+  }
+});
+
+Deno.test({
+  name: "inc_foo#test",
+  fn: () => {
+    using foo = new Foo(22);
+    inc_foo(foo);
+    assertEquals(foo.bar(0), 23);
+  }
 })