functionalscript 0.0.415 → 0.0.418

package/.github/workflows/deno.yml

@@ -13,5 +13,5 @@ jobs:
     - uses: actions/checkout@v2
     - uses: denoland/setup-deno@v1
       with:
-        deno-version: v1.x
+        deno-version: v1.25.1
     - run: deno run --unstable --compat --allow-read --allow-env ./test.f.cjs

package/.github/workflows/node.js.yml

@@ -14,7 +14,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
+        node-version: [16.x, 18.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:

package/.github/workflows/npm-publish.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
         with:
-          node-version: 14
+          node-version: 16
       - run: npm ci
       - run: npm test
 
@@ -27,7 +27,7 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-node@v2
         with:
-          node-version: 14
+          node-version: 16
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm run version

package/com/cpp/test.f.cjs

@@ -15,6 +15,7 @@ const f = () =>
         '    {\n' +
         '        uint8_t* Start;\n' +
         '        size_t Size;\n' +
+        '        ::com::ref<IMy> M;\n' +
         '    };\n' +
         '    struct IMy: ::com::IUnknown\n' +
         '    {\n' +

package/com/cs/test.f.cjs

@@ -17,6 +17,7 @@ const f = () =>
         '    {\n' +
         '        public unsafe byte* Start;\n' +
         '        public UIntPtr Size;\n' +
+        '        public IMy M;\n' +
         '    }\n' +
         '    [Guid("C66FB270-2D80-49AD-BB6E-88C1F90B805D")]\n' +
         '    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]\n' +

package/com/rust/module.f.cjs

@@ -1,8 +1,154 @@
 const types = require('../types/module.f.cjs')
+const { paramList } = types
 const text = require('../../text/module.f.cjs')
+const object = require('../../types/object/module.f.cjs')
+const list = require('../../types/list/module.f.cjs')
+const { flat, map, flatMap } = list
+const { entries } = Object
+const { fn } = require('../../types/function/module.f.cjs')
+const { join } = require('../../types/string/module.f.cjs')
 
-/** @type {(name: string) => (library: types.Library) => text.Block} */
-const rust = name => library => []
+/** @type {(field: string) => string} */
+const rustField = field => `pub ${field},`
+
+const mapRustField = map(rustField)
+
+/** @type {(b: list.Thunk<string>) => (name: string) => text.Block} */
+const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`]
+
+const commaJoin = join(', ')
+
+/** @type {(name: string) => string} */
+const ref = name => `${name}::Ref`
+
+/** @type {(name: string) => string} */
+const obj = name => `&${name}::Object`
+
+const self = ['&self']
+
+/** @type {(p: types.Field) => string} */
+const paramName = ([n]) => n
+
+/** @type {(p: types.FieldArray) => string} */
+const call = p => commaJoin(flat([['self'], map(paramName)(paramList(p))]))
+
+/** @type {(m: types.Method) => string} */
+const assign = ([n]) => `${n}: Self::${n},`
+
+const mapAssign = map(assign)
+
+const super_ = 'super::'
+
+/** @type {(library: types.Library) => text.Block} */
+const rust = library => {
+
+    /** @type {(p: string) => (o: (_: string) => string) => (t: types.Type) => string} */
+    const type = p => {
+        /** @type {(o: (_: string) => string) => (t: types.Type) => string} */
+        const f = o => t => {
+            if (typeof t === 'string') { return t }
+            if (t.length === 2) { return `*const ${f(ref)(t[1])}` }
+            const [id] = t
+            const fullId = `${p}${id}`
+            return library[id].interface === undefined ? fullId : o(fullId)
+        }
+        return f
+    }
+
+    /** @type {(p: string) => (o: (_: string) => string) => (f: types.Field) => string} */
+    const pf = p => o => ([name, t]) => `${name}: ${type(p)(o)(t)}`
+
+    const param = pf(super_)(obj)
+
+    const mapParam = map(param)
+
+    const mapField = map(pf('')(ref))
+
+    /** @type {(fa: types.FieldArray) => (name: string) => text.Block} */
+    const struct = fn(entries)
+        .then(mapField)
+        .then(rustStruct)
+        .result
+
+    /** @type {(first: readonly string[]) => (p: types.FieldArray) => string} */
+    const func = first => p => {
+        const result = p._
+        const resultStr = result === undefined ? '' : ` -> ${type(super_)(ref)(result)}`
+        const params = commaJoin(flat([first, mapParam(paramList(p))]))
+        return `(${params})${resultStr}`
+    }
+
+    /** @type {(m: types.Method) => string} */
+    const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`
+
+    /** @type {(m: types.Method) => string} */
+    const traitFn = m => `${headerFn(m)};`
+
+    const mapTraitFn = map(traitFn)
+
+    /** @type {(m: types.Method) => text.Block} */
+    const implFn = m => {
+        const [n, p] = m
+        return [
+            `${headerFn(m)} {`,
+            [`unsafe { (self.interface().${n})(${call(p)}) }`],
+            '}'
+        ]
+    }
+
+    const flatMapImplFn = flatMap(implFn)
+
+    /** @type {(i: types.Interface) => (name: string) => text.Block} */
+    const interface_ = ({ interface: i, guid }) => name => {
+
+        const this_ = ['this: &Object']
+
+        /** @type {(m: types.Method) => string} */
+        const virtualFn = ([n, p]) => `${n}: unsafe extern "system" fn${func(this_)(p)}`
+
+        const e = entries(i)
+
+        const nameEx = `${name}Ex`
+
+        const nameVmt = `${name}Vmt`
+
+        return [
+            `pub mod ${name} {`,
+            [
+                'type Object = nanocom::Object<Interface>;',
+                'type Ref = nanocom::Ref<Interface>;',
+                'type Vmt = nanocom::Vmt<Interface>;',
+            ],
+            rustStruct(map(virtualFn)(e))('Interface'),
+            [   'impl nanocom::Interface for Interface {',
+                [   `const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`],
+                '}',
+                'pub trait Ex {',
+                mapTraitFn(e),
+                '}',
+                'impl Ex for Object {',
+                flatMapImplFn(e),
+                '}',
+                'pub trait ClassEx: nanocom::Class<Interface = Interface>',
+                'where',
+                [   'nanocom::CObject<Self>: Ex,'],
+                '{',
+                [   `const INTERFACE: Interface = Interface {`,
+                    mapAssign(e),
+                    '};'
+                ],
+                '}',
+                'impl<T: nanocom::Class<Interface = Interface>> ClassEx for T where nanocom::CObject<T>: Ex {}',
+            ],
+            '}'
+        ]
+    }
+
+    /** @type {(type: object.Entry<types.Definition>) => text.Block} */
+    const def = ([name, type]) => (type.interface === undefined ? struct(type.struct) : interface_(type))(name)
+
+    return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))])
+}
 
 module.exports = {
     /** @readonly */

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

@@ -35,7 +35,7 @@ impl<T: Class> CObject<T> {
     };
 
     #[allow(non_snake_case)]
-    extern "stdcall" fn QueryInterface(
+    extern "system" fn QueryInterface(
         this: &Object<T::Interface>,
         riid: &u128,
         ppv_object: &mut *const Object,
@@ -51,7 +51,7 @@ impl<T: Class> CObject<T> {
     }
 
     #[allow(non_snake_case)]
-    extern "stdcall" fn AddRef(this: &Object<T::Interface>) -> u32 {
+    extern "system" fn AddRef(this: &Object<T::Interface>) -> u32 {
         unsafe { T::to_cobject(this) }
             .counter
             .fetch_add(1, Ordering::Relaxed)
@@ -59,7 +59,7 @@ impl<T: Class> CObject<T> {
     }
 
     #[allow(non_snake_case)]
-    extern "stdcall" fn Release(this: &Object<T::Interface>) -> u32 {
+    extern "system" fn Release(this: &Object<T::Interface>) -> u32 {
         let t = unsafe { T::to_cobject(this) };
         match t.counter.fetch_sub(1, Ordering::Relaxed) {
             1 => {

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

@@ -3,11 +3,11 @@ use crate::{hresult::HRESULT, Object, GUID};
 #[allow(non_snake_case)]
 #[repr(C)]
 pub struct IUnknown<I: 'static> {
-    pub QueryInterface: unsafe extern "stdcall" fn(
+    pub QueryInterface: unsafe extern "system" 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,
+    pub AddRef: unsafe extern "system" fn(this: &Object<I>) -> u32,
+    pub Release: unsafe extern "system" fn(this: &Object<I>) -> u32,
 }

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

@@ -1,4 +1,8 @@
-use std::{cmp::Eq, fmt::{Debug, Formatter}, ops::Deref};
+use std::{
+    cmp::Eq,
+    fmt::{Debug, Formatter},
+    ops::Deref,
+};
 
 use crate::object::Object;
 

package/com/rust/nanocom/tests/it.rs

@@ -1,26 +1,25 @@
+#![allow(non_snake_case)]
+
 // 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,
+        pub A: unsafe extern "system" fn(this: &Object<IMy>) -> Ref<IMy>,
+        pub B: unsafe extern "system" 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) }
@@ -42,15 +41,14 @@ mod library {
 
     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> {
+        extern "system" fn A(this: &Object<IMy>) -> Ref<IMy> {
             unsafe { Self::to_cobject(this) }.A()
         }
-        extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
+        extern "system" fn B(this: &Object<IMy>) -> u32 {
             unsafe { Self::to_cobject(this) }.B()
         }
     }

package/com/rust/nanocom/tests/itmod.rs

@@ -0,0 +1,196 @@
+#![allow(non_snake_case)]
+
+// interface definition:
+
+mod library {
+    pub mod IMy {
+        pub type Object = nanocom::Object<Interface>;
+        pub type Ref = nanocom::Ref<Interface>;
+        pub type Vmt = nanocom::Vmt<Interface>;
+
+        #[repr(C)]
+        pub struct Interface {
+            pub A: unsafe extern "system" fn(this: &Object) -> Ref,
+            pub B: unsafe extern "system" fn(this: &Object) -> u32,
+        }
+
+        impl nanocom::Interface for Interface {
+            const GUID: nanocom::GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
+        }
+
+        pub trait Ex {
+            fn A(&self) -> Ref;
+            fn B(&self) -> u32;
+        }
+
+        impl Ex for Object {
+            fn A(&self) -> Ref {
+                unsafe { (self.interface().A)(self) }
+            }
+            fn B(&self) -> u32 {
+                unsafe { (self.interface().B)(self) }
+            }
+        }
+
+        pub trait ClassEx: nanocom::Class<Interface = Interface>
+        where
+            nanocom::CObject<Self>: Ex,
+        {
+            const INTERFACE: Interface = Interface {
+                A: Self::A,
+                B: Self::B,
+            };
+        }
+
+        impl<T: nanocom::Class<Interface = Interface>> ClassEx for T where nanocom::CObject<T>: Ex {}
+
+        trait PrivateClassEx: nanocom::Class<Interface = Interface>
+        where
+            nanocom::CObject<Self>: Ex,
+        {
+            extern "system" fn A(this: &Object) -> Ref {
+                unsafe { Self::to_cobject(this) }.A()
+            }
+            extern "system" fn B(this: &Object) -> u32 {
+                unsafe { Self::to_cobject(this) }.B()
+            }
+        }
+
+        impl<T: nanocom::Class<Interface = Interface>> PrivateClassEx for T where nanocom::CObject<T>: Ex {}
+    }
+}
+
+// interface implementation
+mod number {
+    use nanocom::{CObject, Vmt};
+
+    use crate::library::IMy::ClassEx;
+
+    use super::library::IMy;
+
+    pub struct X(pub u32);
+
+    impl nanocom::Class for X {
+        type Interface = IMy::Interface;
+        fn static_vmt() -> &'static Vmt<Self::Interface> {
+            static V: IMy::Vmt = Vmt {
+                iunknown: X::IUNKNOWN,
+                interface: X::INTERFACE,
+            };
+            &V
+        }
+    }
+
+    impl IMy::Ex for CObject<X> {
+        fn A(&self) -> IMy::Ref {
+            self.to_interface().into()
+        }
+        fn B(&self) -> u32 {
+            self.value.0
+        }
+    }
+}
+
+mod use_number {
+    use nanocom::Class;
+
+    use crate::library::IMy::Ex;
+
+    use super::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, Vmt};
+
+    use crate::library::IMy::ClassEx;
+
+    use super::library::IMy;
+
+    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 nanocom::Class for X {
+        type Interface = IMy::Interface;
+        fn static_vmt() -> &'static Vmt<Self::Interface> {
+            static V: IMy::Vmt = Vmt {
+                iunknown: X::IUNKNOWN,
+                interface: X::INTERFACE,
+            };
+            &V
+        }
+    }
+
+    impl IMy::Ex for CObject<X> {
+        fn A(&self) -> IMy::Ref {
+            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::library::IMy::Ex;
+
+    use super::destructor::X;
+
+    #[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/test.f.cjs

@@ -4,8 +4,75 @@ const { join } = require('../../types/string/module.f.cjs')
 const library = require('../types/test.f.cjs')
 
 {
-    const r = join('\n')(flat('    ')(rust('My')(library)))
-    if (r !== '') { throw r }
+    const e =
+        '#![allow(non_snake_case)]\n' +
+        '#[repr(C)]\n' +
+        'pub struct Slice {\n' +
+        '    pub Start: *const u8,\n' +
+        '    pub Size: usize,\n' +
+        '    pub M: IMy::Ref,\n' +
+        '}\n' +
+        'pub mod IMy {\n' +
+        '    type Object = nanocom::Object<Interface>;\n' +
+        '    type Ref = nanocom::Ref<Interface>;\n' +
+        '    type Vmt = nanocom::Vmt<Interface>;\n' +
+        '    #[repr(C)]\n' +
+        '    pub struct Interface {\n' +
+        '        pub GetSlice: unsafe extern "system" fn(this: &Object) -> super::Slice,\n' +
+        '        pub SetSlice: unsafe extern "system" fn(this: &Object, slice: super::Slice),\n' +
+        '        pub GetUnsafe: unsafe extern "system" fn(this: &Object) -> *const bool,\n' +
+        '        pub SetUnsafe: unsafe extern "system" fn(this: &Object, p: *const super::Slice, size: u32),\n' +
+        '        pub Some: unsafe extern "system" fn(this: &Object, p: &super::IMy::Object) -> bool,\n' +
+        '        pub GetIMy: unsafe extern "system" fn(this: &Object) -> super::IMy::Ref,\n' +
+        '    }\n' +
+        '    impl nanocom::Interface for Interface {\n' +
+        '        const GUID: nanocom::GUID = 0xC66FB270_2D80_49AD_BB6E_88C1F90B805D;\n' +
+        '    }\n' +
+        '    pub trait Ex {\n' +
+        '        fn GetSlice(&self) -> super::Slice;\n' +
+        '        fn SetSlice(&self, slice: super::Slice);\n' +
+        '        fn GetUnsafe(&self) -> *const bool;\n' +
+        '        fn SetUnsafe(&self, p: *const super::Slice, size: u32);\n' +
+        '        fn Some(&self, p: &super::IMy::Object) -> bool;\n' +
+        '        fn GetIMy(&self) -> super::IMy::Ref;\n' +
+        '    }\n' +
+        '    impl Ex for Object {\n' +
+        '        fn GetSlice(&self) -> super::Slice {\n' +
+        '            unsafe { (self.interface().GetSlice)(self) }\n' +
+        '        }\n' +
+        '        fn SetSlice(&self, slice: super::Slice) {\n' +
+        '            unsafe { (self.interface().SetSlice)(self, slice) }\n' +
+        '        }\n' +
+        '        fn GetUnsafe(&self) -> *const bool {\n' +
+        '            unsafe { (self.interface().GetUnsafe)(self) }\n' +
+        '        }\n' +
+        '        fn SetUnsafe(&self, p: *const super::Slice, size: u32) {\n' +
+        '            unsafe { (self.interface().SetUnsafe)(self, p, size) }\n' +
+        '        }\n' +
+        '        fn Some(&self, p: &super::IMy::Object) -> bool {\n' +
+        '            unsafe { (self.interface().Some)(self, p) }\n' +
+        '        }\n' +
+        '        fn GetIMy(&self) -> super::IMy::Ref {\n' +
+        '            unsafe { (self.interface().GetIMy)(self) }\n' +
+        '        }\n' +
+        '    }\n' +
+        '    pub trait ClassEx: nanocom::Class<Interface = Interface>\n' +
+        '    where\n' +
+        '        nanocom::CObject<Self>: Ex,\n' +
+        '    {\n' +
+        '        const INTERFACE: Interface = Interface {\n' +
+        '            GetSlice: Self::GetSlice,\n' +
+        '            SetSlice: Self::SetSlice,\n' +
+        '            GetUnsafe: Self::GetUnsafe,\n' +
+        '            SetUnsafe: Self::SetUnsafe,\n' +
+        '            Some: Self::Some,\n' +
+        '            GetIMy: Self::GetIMy,\n' +
+        '        };\n' +
+        '    }\n' +
+        '    impl<T: nanocom::Class<Interface = Interface>> ClassEx for T where nanocom::CObject<T>: Ex {}\n' +
+        '}'
+    const r = join('\n')(flat('    ')(rust(library)))
+    if (r !== e) { throw [e, r] }
 }
 
 module.exports = {}

package/com/types/test.f.cjs

@@ -6,6 +6,7 @@ module.exports = {
         struct: {
             Start: ['*', 'u8'],
             Size: 'usize',
+            M: ['IMy'],
         },
     },
     IMy: {

package/package.json

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

package/tsconfig.json

@@ -96,5 +96,6 @@
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
+  },
+  "exclude": ["target"]
 }