functionalscript 0.0.412 → 0.0.413

package/Cargo.lock

@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "nanocom"
-version = "0.1.0"
+version = "0.1.2"
 
 [[package]]
 name = "rstest"

package/com/rust/nanocom/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "nanocom"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2021"
-description = "Nano-Com"
+description = "Nano-COM, extremly small subset of cross-platform COM"
+authors = ["NatFoam"]
 license = "MIT"
+homepage = "https://github.com/functionalscript/functionalscript/tree/main/com/rust/nanocom"
+repository = "https://github.com/functionalscript/functionalscript"
+keywords = ["com", "xpcom", "abi"]
+categories = ["development-tools::ffi", "external-ffi-bindings", "api-bindings"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

package/com/rust/nanocom/rstest/src/lib.rs

@@ -61,7 +61,7 @@ mod test {
     }
 
     // interface implementation
-    mod x {
+    mod number {
         use nanocom::{CObject, Class, Ref, Vmt};
 
         use super::library::{IMy, IMyEx, IMyVmt};
@@ -90,10 +90,10 @@ mod test {
         }
     }
 
-    mod using {
+    mod use_number {
         use nanocom::Class;
 
-        use crate::test::{library::IMyEx, x::X};
+        use crate::test::{library::IMyEx, number::X};
 
         #[test]
         fn test() {
@@ -106,4 +106,86 @@ mod test {
             assert_eq!(b.B(), 43);
         }
     }
+
+    mod destructor {
+        use std::{
+            rc::Rc,
+            sync::atomic::{AtomicU32, Ordering},
+        };
+
+        use nanocom::{CObject, Class, Ref, Vmt};
+
+        use super::library::{IMy, IMyEx, IMyVmt};
+
+        pub struct X {
+            p: Rc<AtomicU32>,
+        }
+
+        impl X {
+            pub fn new(p: Rc<AtomicU32>) -> Self {
+                p.fetch_add(1, Ordering::Relaxed);
+                Self { p }
+            }
+        }
+
+        impl Drop for X {
+            fn drop(&mut self) {
+                self.p.fetch_sub(1, Ordering::Relaxed);
+            }
+        }
+
+        impl Class for X {
+            type Interface = IMy;
+            fn static_vmt() -> &'static Vmt<Self::Interface> {
+                static V: Vmt<IMy> = Vmt {
+                    iunknown: X::IUNKNOWN,
+                    interface: X::INTERFACE,
+                };
+                &V
+            }
+        }
+
+        #[allow(non_snake_case)]
+        impl IMyEx for CObject<X> {
+            fn A(&self) -> Ref<IMy> {
+                self.to_interface().into()
+            }
+            fn B(&self) -> u32 {
+                self.value.p.load(Ordering::Relaxed)
+            }
+        }
+    }
+
+    mod use_destructor {
+        use std::{
+            rc::Rc,
+            sync::atomic::{AtomicU32, Ordering},
+        };
+
+        use nanocom::Class;
+
+        use crate::test::{destructor::X, library::IMyEx};
+
+        #[test]
+        fn test() {
+            let p = Rc::new(AtomicU32::default());
+            {
+                assert_eq!(p.load(Ordering::Relaxed), 0);
+                let a = X::new(p.clone()).cobject_new();
+                assert_eq!(p.load(Ordering::Relaxed), 1);
+                let a1 = a.A();
+                assert_eq!(p.load(Ordering::Relaxed), 1);
+                assert_eq!(a, a1);
+                assert_eq!(a.B(), 1);
+                {
+                    let b = X::new(p.clone()).cobject_new();
+                    assert_eq!(p.load(Ordering::Relaxed), 2);
+                    assert_ne!(a, b);
+                    assert_eq!(b.B(), 2);
+                }
+                assert_eq!(p.load(Ordering::Relaxed), 1);
+            }
+            assert_eq!(p.load(Ordering::Relaxed), 0);
+        }
+    }
 }

package/com/rust/nanocom/src/class.rs

@@ -1,9 +1,9 @@
-use crate::{iunknownvmt::IUnknownVmt, CObject, Interface, Object, Ref, Vmt};
+use crate::{iunknown::IUnknown, CObject, Interface, Object, Ref, Vmt};
 
 pub trait Class: Sized {
     type Interface: Interface;
     fn static_vmt() -> &'static Vmt<Self::Interface>;
-    const IUNKNOWN: IUnknownVmt<Self::Interface> = CObject::<Self>::IUNKNOWN;
+    const IUNKNOWN: IUnknown<Self::Interface> = CObject::<Self>::IUNKNOWN;
     fn cobject_new(self) -> Ref<Self::Interface> {
         CObject::new(self)
     }

package/com/rust/nanocom/src/cobject.rs

@@ -3,10 +3,7 @@ use std::{
     sync::atomic::{AtomicU32, Ordering},
 };
 
-use crate::{
-    hresult::HRESULT, iunknown::IUnknown, iunknownvmt::IUnknownVmt, Class, Interface, Object, Ref,
-    Vmt,
-};
+use crate::{hresult::HRESULT, iunknown::IUnknown, Class, Interface, Object, Ref, Vmt};
 
 #[repr(C)]
 pub struct CObject<T: Class> {
@@ -31,7 +28,7 @@ impl<T: Class> CObject<T> {
         unsafe { &*p }
     }
 
-    pub const IUNKNOWN: IUnknownVmt<T::Interface> = IUnknownVmt {
+    pub const IUNKNOWN: IUnknown<T::Interface> = IUnknown {
         QueryInterface: Self::QueryInterface,
         AddRef: Self::AddRef,
         Release: Self::Release,
@@ -41,11 +38,11 @@ impl<T: Class> CObject<T> {
     extern "stdcall" fn QueryInterface(
         this: &Object<T::Interface>,
         riid: &u128,
-        ppv_object: &mut *const Object<IUnknown>,
+        ppv_object: &mut *const Object,
     ) -> HRESULT {
-        let (p, r) = if *riid == IUnknown::GUID || *riid == T::Interface::GUID {
+        let (p, r) = if *riid == <()>::GUID || *riid == T::Interface::GUID {
             Self::AddRef(this);
-            (this.to_iunknown() as *const Object<IUnknown>, HRESULT::S_OK)
+            (this.to_iunknown() as *const Object, HRESULT::S_OK)
         } else {
             (null(), HRESULT::E_NOINTERFACE)
         };

package/com/rust/nanocom/src/interface.rs

@@ -3,3 +3,7 @@ use crate::guid::GUID;
 pub trait Interface: 'static {
     const GUID: GUID;
 }
+
+impl Interface for () {
+    const GUID: GUID = 0x00000000_0000_0000_C000_000000000046;
+}

package/com/rust/nanocom/src/iunknown.rs

@@ -1,7 +1,13 @@
-use crate::{guid::GUID, interface::Interface};
+use crate::{hresult::HRESULT, Object, GUID};
 
-pub struct IUnknown();
-
-impl Interface for IUnknown {
-    const GUID: GUID = 0x00000000_0000_0000_C000_000000000046;
+#[allow(non_snake_case)]
+#[repr(C)]
+pub struct IUnknown<I: 'static> {
+    pub QueryInterface: unsafe extern "stdcall" fn(
+        this: &Object<I>,
+        riid: &GUID,
+        ppv_object: &mut *const Object,
+    ) -> HRESULT,
+    pub AddRef: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
+    pub Release: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
 }

package/com/rust/nanocom/src/lib.rs

@@ -4,12 +4,11 @@ mod guid;
 mod hresult;
 mod interface;
 mod iunknown;
-mod iunknownvmt;
 mod object;
 mod r#ref;
 mod vmt;
 
 pub use crate::{
-    class::Class, cobject::CObject, guid::GUID, interface::Interface, object::Object, r#ref::Ref,
-    vmt::Vmt,
+    class::Class, cobject::CObject, guid::GUID, interface::Interface, iunknown::IUnknown,
+    object::Object, r#ref::Ref, vmt::Vmt,
 };

package/com/rust/nanocom/src/object.rs

@@ -1,21 +1,18 @@
-use crate::{
-    hresult::HRESULT, interface::Interface, iunknown::IUnknown, iunknownvmt::IUnknownVmt,
-    r#ref::Ref, vmt::Vmt,
-};
+use crate::{hresult::HRESULT, interface::Interface, iunknown::IUnknown, r#ref::Ref, vmt::Vmt};
 use std::ptr::null;
 
 #[repr(C)]
-pub struct Object<I: 'static>(&'static Vmt<I>);
+pub struct Object<I: 'static = ()>(&'static Vmt<I>);
 
 impl<I> Object<I> {
-    pub unsafe fn iunknown(&self) -> &'static IUnknownVmt<I> {
+    pub unsafe fn iunknown(&self) -> &'static IUnknown<I> {
         &self.0.iunknown
     }
     pub unsafe fn interface(&self) -> &'static I {
         &self.0.interface
     }
-    pub fn to_iunknown(&self) -> &Object<IUnknown> {
-        let p = self as *const Object<I> as *const Object<IUnknown>;
+    pub fn to_iunknown(&self) -> &Object {
+        let p = self as *const Object<I> as *const Object;
         unsafe { &*p }
     }
     pub fn query_interface<J: Interface>(&self) -> Result<Ref<J>, HRESULT> {
@@ -28,7 +25,7 @@ impl<I> Object<I> {
             e => Err(e),
         }
     }
-    pub fn query_iunknown(&self) -> Ref<IUnknown> {
+    pub fn query_iunknown(&self) -> Ref {
         self.query_interface().unwrap()
     }
 }

package/com/rust/nanocom/src/ref.rs

@@ -1,9 +1,9 @@
-use std::{cmp::Eq, fmt::Debug, ops::Deref};
+use std::{cmp::Eq, fmt::{Debug, Formatter}, ops::Deref};
 
 use crate::object::Object;
 
 #[repr(transparent)]
-pub struct Ref<I: 'static>(*const Object<I>);
+pub struct Ref<I: 'static = ()>(*const Object<I>);
 
 impl<I: 'static> Ref<I> {
     pub unsafe fn from_raw(p: *const Object<I>) -> Ref<I> {
@@ -39,7 +39,7 @@ impl<I> From<&Object<I>> for Ref<I> {
 }
 
 impl<I> Debug for Ref<I> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("Ref").field(&self.0).finish()
     }
 }

package/com/rust/nanocom/src/vmt.rs

@@ -1,7 +1,7 @@
-use crate::iunknownvmt::IUnknownVmt;
+use crate::iunknown::IUnknown;
 
 #[repr(C)]
 pub struct Vmt<I: 'static> {
-    pub iunknown: IUnknownVmt<I>,
+    pub iunknown: IUnknown<I>,
     pub interface: I,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.412",
+  "version": "0.0.413",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/com/rust/nanocom/src/iunknownvmt.rs

@@ -1,13 +0,0 @@
-use crate::{hresult::HRESULT, iunknown::IUnknown, Object, GUID};
-
-#[allow(non_snake_case)]
-#[repr(C)]
-pub struct IUnknownVmt<I: 'static> {
-    pub QueryInterface: unsafe extern "stdcall" fn(
-        this: &Object<I>,
-        riid: &GUID,
-        ppv_object: &mut *const Object<IUnknown>,
-    ) -> HRESULT,
-    pub AddRef: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
-    pub Release: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
-}