functionalscript 0.0.412 → 0.0.415

package/Cargo.lock

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

package/Cargo.toml

@@ -1,5 +1,4 @@
 [workspace]
 members = [
-    "com/rust/nanocom",
-    "com/rust/nanocom/rstest",
+    "com/rust/nanocom"
 ]

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/README.md

@@ -1,3 +1,56 @@
 # Nano-COM
 
-See [Nano-COM](https://en.wikipedia.org/wiki/Component_Object_Model#Nano-COM_(a.k.a_XPCOM)).
+See [Nano-COM](https://en.wikipedia.org/wiki/Component_Object_Model#Nano-COM_(a.k.a_XPCOM)).
+
+## Function Stack
+
+- a public function.
+  ```rust
+  let o: Object<IMy> = ...;
+  // calling a public function
+  let i: u32 = o.B();
+  ```
+  ```rust
+  trait IMyEx {
+      // a definition
+      fn B(&self) -> u32;
+  }
+  impl IMyEx for Object<IMy> {
+      // an implementation of the public function
+      fn B(&self) -> u32 {
+          // calling a virtual function.
+          unsafe { (self.interface().B()(self) }
+      }
+  }
+  ```
+- a virtual function.
+  ```rust
+  #[repr(C)]
+  pub struct IMy {
+      // a definiton of the virtual function
+      pub B: unsafe extern "stdcall" fn(this: &Object<IMy>) -> u32
+  }
+  trait IMyVmtFn: Class<Interface = IMy>
+  where
+      CObject<Self>: IMyEx
+  {
+      // an implementation of the virtual function
+      extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
+          // calling a function implementation
+          unsafe { Self::to_cobject(this) }.B()
+      }
+  }
+  ```
+- a function implementation.
+  ```rust
+  trait IMyEx {
+      // a definition
+      fn B(&self) -> u32;
+  }
+  impl IMyEx for CObject<X> {
+      // an implementation of the function.
+      fn B(&self) -> u32 {
+          self.value.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/com/rust/nanocom/tests/it.rs

@@ -0,0 +1,188 @@
+// interface definition:
+
+mod library {
+    use nanocom::{CObject, Class, Interface, Object, Ref, GUID};
+
+    #[allow(non_snake_case)]
+    #[repr(C)]
+    pub struct IMy {
+        pub A: unsafe extern "stdcall" fn(this: &Object<IMy>) -> Ref<IMy>,
+        pub B: unsafe extern "stdcall" fn(this: &Object<IMy>) -> u32,
+    }
+
+    impl Interface for IMy {
+        const GUID: GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
+    }
+
+    #[allow(non_snake_case)]
+    pub trait IMyEx {
+        fn A(&self) -> Ref<IMy>;
+        fn B(&self) -> u32;
+    }
+
+    #[allow(non_snake_case)]
+    impl IMyEx for Object<IMy> {
+        fn A(&self) -> Ref<IMy> {
+            unsafe { (self.interface().A)(self) }
+        }
+        fn B(&self) -> u32 {
+            unsafe { (self.interface().B)(self) }
+        }
+    }
+
+    pub trait IMyVmt: Class<Interface = IMy>
+    where
+        CObject<Self>: IMyEx,
+    {
+        const INTERFACE: IMy = IMy {
+            A: Self::A,
+            B: Self::B,
+        };
+    }
+
+    impl<T: Class<Interface = IMy>> IMyVmt for T where CObject<T>: IMyEx {}
+
+    #[allow(non_snake_case)]
+    trait IMyVmtFn: Class<Interface = IMy>
+    where
+        CObject<Self>: IMyEx,
+    {
+        extern "stdcall" fn A(this: &Object<IMy>) -> Ref<IMy> {
+            unsafe { Self::to_cobject(this) }.A()
+        }
+        extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
+            unsafe { Self::to_cobject(this) }.B()
+        }
+    }
+
+    impl<T: Class<Interface = IMy>> IMyVmtFn for T where CObject<T>: IMyEx {}
+}
+
+// interface implementation
+mod number {
+    use nanocom::{CObject, Class, Ref, Vmt};
+
+    use super::library::{IMy, IMyEx, IMyVmt};
+
+    pub struct X(pub u32);
+
+    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.0
+        }
+    }
+}
+
+mod use_number {
+    use nanocom::Class;
+
+    use super::{library::IMyEx, number::X};
+
+    #[test]
+    fn test() {
+        let a = X(42).cobject_new();
+        let a1 = a.A();
+        assert_eq!(a, a1);
+        assert_eq!(a.B(), 42);
+        let b = X(43).cobject_new();
+        assert_ne!(a, b);
+        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 super::{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/package.json

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

package/com/rust/nanocom/rstest/Cargo.lock

@@ -1,14 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "com"
-version = "0.1.0"
-
-[[package]]
-name = "rstest"
-version = "0.1.0"
-dependencies = [
- "com",
-]

package/com/rust/nanocom/rstest/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "rstest"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-nanocom = { path = ".." }

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

@@ -1,109 +0,0 @@
-#[cfg(test)]
-mod test {
-    // interface definition:
-
-    mod library {
-        use nanocom::{CObject, Class, Interface, Object, Ref, GUID};
-
-        #[allow(non_snake_case)]
-        #[repr(C)]
-        pub struct IMy {
-            pub A: unsafe extern "stdcall" fn(this: &Object<IMy>) -> Ref<IMy>,
-            pub B: unsafe extern "stdcall" fn(this: &Object<IMy>) -> u32,
-        }
-
-        impl Interface for IMy {
-            const GUID: GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
-        }
-
-        #[allow(non_snake_case)]
-        pub trait IMyEx {
-            fn A(&self) -> Ref<IMy>;
-            fn B(&self) -> u32;
-        }
-
-        #[allow(non_snake_case)]
-        impl IMyEx for Object<IMy> {
-            fn A(&self) -> Ref<IMy> {
-                unsafe { (self.interface().A)(self) }
-            }
-            fn B(&self) -> u32 {
-                unsafe { (self.interface().B)(self) }
-            }
-        }
-
-        pub trait IMyVmt: Class<Interface = IMy>
-        where
-            CObject<Self>: IMyEx,
-        {
-            const INTERFACE: IMy = IMy {
-                A: Self::A,
-                B: Self::B,
-            };
-        }
-
-        impl<T: Class<Interface = IMy>> IMyVmt for T where CObject<T>: IMyEx {}
-
-        #[allow(non_snake_case)]
-        trait IMyVmtFn: Class<Interface = IMy>
-        where
-            CObject<Self>: IMyEx,
-        {
-            extern "stdcall" fn A(this: &Object<IMy>) -> Ref<IMy> {
-                unsafe { Self::to_cobject(this) }.A()
-            }
-            extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
-                unsafe { Self::to_cobject(this) }.B()
-            }
-        }
-
-        impl<T: Class<Interface = IMy>> IMyVmtFn for T where CObject<T>: IMyEx {}
-    }
-
-    // interface implementation
-    mod x {
-        use nanocom::{CObject, Class, Ref, Vmt};
-
-        use super::library::{IMy, IMyEx, IMyVmt};
-
-        pub struct X(pub u32);
-
-        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.0
-            }
-        }
-    }
-
-    mod using {
-        use nanocom::Class;
-
-        use crate::test::{library::IMyEx, x::X};
-
-        #[test]
-        fn test() {
-            let a = X(42).cobject_new();
-            let a1 = a.A();
-            assert_eq!(a, a1);
-            assert_eq!(a.B(), 42);
-            let b = X(43).cobject_new();
-            assert_ne!(a, b);
-            assert_eq!(b.B(), 43);
-        }
-    }
-}

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,
-}