Merge pull request #54 from stepfunc/feature/manual-dispose

Add manual dispose flag in the schema to remove IDisposable/AutoCloseable

Author: emgre

generators/dotnet-oo-bindgen/src/class.rs

@@ -20,7 +20,7 @@ pub(crate) fn generate(
         })?;
 
         f.writeln(&format!("public sealed class {}", classname))?;
-        if class.destructor.is_some() {
+        if class.is_manual_destruction() {
             f.write(": IDisposable")?;
         }
 
@@ -55,7 +55,13 @@ pub(crate) fn generate(
             }
 
             if let Some(destructor) = &class.destructor {
-                generate_destructor(f, &classname, destructor, lib)?;
+                generate_destructor(
+                    f,
+                    &classname,
+                    destructor,
+                    class.is_manual_destruction(),
+                    lib,
+                )?;
                 f.newline()?;
             }
 
@@ -171,23 +177,26 @@ fn generate_destructor(
     f: &mut dyn Printer,
     classname: &str,
     destructor: &NativeFunctionHandle,
+    is_manual_destruction: bool,
     lib: &Library,
 ) -> FormattingResult<()> {
-    // Public Dispose method
-    documentation(f, |f| xmldoc_print(f, &destructor.doc, lib))?;
+    if is_manual_destruction {
+        // Public Dispose method
+        documentation(f, |f| xmldoc_print(f, &destructor.doc, lib))?;
 
-    f.writeln("public void Dispose()")?;
-    blocked(f, |f| {
-        f.writeln("Dispose(true);")?;
-        f.writeln("GC.SuppressFinalize(this);")
-    })?;
+        f.writeln("public void Dispose()")?;
+        blocked(f, |f| {
+            f.writeln("Dispose(true);")?;
+            f.writeln("GC.SuppressFinalize(this);")
+        })?;
 
-    f.newline()?;
+        f.newline()?;
+    }
 
     // Finalizer
     documentation(f, |f| {
         f.writeln("<summary>")?;
-        f.writeln("Finalizer")?;
+        f.write("Finalizer")?;
         f.write("</summary>")
     })?;
     f.writeln(&format!("~{}()", classname))?;

generators/java-oo-bindgen/src/java/class.rs

@@ -16,7 +16,7 @@ pub(crate) fn generate(
 
     // Class definition
     f.writeln(&format!("public final class {}", classname))?;
-    if class.destructor.is_some() {
+    if class.is_manual_destruction() {
         f.write(" implements AutoCloseable")?;
     }
 
@@ -39,7 +39,7 @@ pub(crate) fn generate(
         }
 
         if let Some(destructor) = &class.destructor {
-            generate_destructor(f, destructor, lib)?;
+            generate_destructor(f, destructor, class.is_manual_destruction(), lib)?;
             f.newline()?;
         }
 
@@ -145,25 +145,33 @@ fn generate_constructor(
 fn generate_destructor(
     f: &mut dyn Printer,
     destructor: &NativeFunctionHandle,
+    is_manual_destruction: bool,
     lib: &Library,
 ) -> FormattingResult<()> {
-    documentation(f, |f| {
-        // Print top-level documentation
-        javadoc_print(f, &destructor.doc, lib)?;
-        f.newline()?;
+    if is_manual_destruction {
+        documentation(f, |f| {
+            // Print top-level documentation
+            javadoc_print(f, &destructor.doc, lib)?;
+            f.newline()?;
 
-        // Print each parameter value
-        for param in destructor.parameters.iter().skip(1) {
-            f.writeln(&format!("@param {} ", param.name.to_mixed_case()))?;
-            docstring_print(f, &param.doc, lib)?;
-        }
+            // Print each parameter value
+            for param in destructor.parameters.iter().skip(1) {
+                f.writeln(&format!("@param {} ", param.name.to_mixed_case()))?;
+                docstring_print(f, &param.doc, lib)?;
+            }
 
-        Ok(())
-    })?;
+            Ok(())
+        })?;
+    }
+
+    if is_manual_destruction {
+        // AutoCloseable implementation
+        f.writeln("@Override")?;
+        f.writeln("public void close()")?;
+    } else {
+        f.writeln("private void close()")?;
+    }
 
-    // AutoCloseable implementation
-    f.writeln("@Override")?;
-    f.writeln("public void close()")?;
     blocked(f, |f| {
         f.writeln("if (this.disposed.getAndSet(true))")?;
         f.writeln("    return;")?;

oo-bindgen/src/class.rs

@@ -33,6 +33,18 @@ pub struct AsyncMethod {
     pub callback_param_name: String,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
+pub enum DestructionMode {
+    /// Object is automatically deleted by the GC
+    Automatic,
+    /// Object is disposed of manually by calling a dispose()/close() method
+    ///
+    /// For safety, if the user never calls the destruction method, the object
+    /// will still be deleted by the GC at some point. However, it is
+    /// strongly advised to take care of the destruction manually.
+    Manual,
+}
+
 /// Object-oriented class definition
 #[derive(Debug)]
 pub struct Class {
@@ -43,6 +55,7 @@ pub struct Class {
     pub static_methods: Vec<Method>,
     pub async_methods: Vec<AsyncMethod>,
     pub doc: Doc,
+    pub destruction_mode: DestructionMode,
 }
 
 impl Class {
@@ -54,6 +67,10 @@ impl Class {
         self.declaration.clone()
     }
 
+    pub fn is_manual_destruction(&self) -> bool {
+        self.destruction_mode == DestructionMode::Manual && self.destructor.is_some()
+    }
+
     pub fn find_method<T: AsRef<str>>(&self, method_name: T) -> Option<&NativeFunctionHandle> {
         for method in &self.methods {
             if method.name == method_name.as_ref() {
@@ -88,6 +105,7 @@ pub struct ClassBuilder<'a> {
     static_methods: Vec<Method>,
     async_methods: Vec<AsyncMethod>,
     doc: Option<Doc>,
+    destruction_mode: DestructionMode,
 }
 
 impl<'a> ClassBuilder<'a> {
@@ -101,6 +119,7 @@ impl<'a> ClassBuilder<'a> {
             static_methods: Vec::new(),
             async_methods: Vec::new(),
             doc: None,
+            destruction_mode: DestructionMode::Automatic,
         }
     }
 
@@ -272,6 +291,11 @@ impl<'a> ClassBuilder<'a> {
         Ok(self)
     }
 
+    pub fn manual_destroy(mut self) -> Result<Self> {
+        self.destruction_mode = DestructionMode::Manual;
+        Ok(self)
+    }
+
     pub fn build(self) -> Result<ClassHandle> {
         let doc = match self.doc {
             Some(doc) => doc,
@@ -290,6 +314,7 @@ impl<'a> ClassBuilder<'a> {
             static_methods: self.static_methods,
             async_methods: self.async_methods,
             doc,
+            destruction_mode: self.destruction_mode,
         });
 
         self.lib

tests/bindings/dotnet/foo.Tests/CallbackTest.cs

@@ -59,7 +59,7 @@ public class CallbackTests
         [Fact]
         public void CallbackTest()
         {
-            using (var cbSource = new CallbackSource())
+            using(var cbSource = new CallbackSource())
             {
                 var cb = new CallbackImpl();
                 cbSource.SetInterface(cb);
@@ -78,7 +78,7 @@ public void CallbackTest()
 
         private void singleRun(Counters counters)
         {
-            using (var cbSource = new CallbackSource())
+            using(var cbSource = new CallbackSource())
             {
                 cbSource.SetInterface(new CallbackFinalizerCounterImpl(counters));
                 cbSource.SetValue(76);

tests/foo-schema/src/callback.rs

@@ -101,6 +101,7 @@ pub fn define(lib: &mut LibraryBuilder) -> Result<(), BindingError> {
         .method("SetInterface", &cbsource_set_interface)?
         .method("SetValue", &cbsource_set_value_func)?
         .method("SetDuration", &cbsource_set_duration_func)?
+        .manual_destroy()?
         .doc("CallbackSource class")?
         .build()?;
 

tests/foo-schema/src/class.rs

@@ -102,6 +102,7 @@ pub fn define(lib: &mut LibraryBuilder) -> Result<(), BindingError> {
         .method("IncrementValue", &testclass_increment_value_func)?
         .async_method("GetValueAsync", &testclass_get_value_async_func)?
         .static_method("ConstructionCounter", &testclass_construction_counter)?
+        .manual_destroy()?
         .doc("TestClass")?
         .build()?;
 

tests/foo-schema/src/strings.rs

@@ -52,6 +52,7 @@ pub fn define(lib: &mut LibraryBuilder) -> Result<(), BindingError> {
         .destructor(&stringclass_destroy_func)?
         .method("Echo", &stringclass_echo_func)?
         .static_method("GetLength", &stringclass_length_func)?
+        .manual_destroy()?
         .doc("StringClass")?
         .build()?;