functionalscript 0.0.426 → 0.0.427

package/Cargo.lock

@@ -5,3 +5,10 @@ version = 3
 [[package]]
 name = "nanocom"
 version = "0.1.2"
+
+[[package]]
+name = "rtest"
+version = "0.1.0"
+dependencies = [
+ "nanocom",
+]

package/Cargo.toml

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

package/com/cpp/test/build.cjs

@@ -1,7 +1,7 @@
 const fs = require('node:fs')
 const cp = require('node:child_process')
 const os = require('node:os');
-const cpp = require('../testlib.f.cjs').result
+const cpp = require('../test.f.cjs').result
 const { string: { join }, list: { flat } } = require('../../../types/module.f.cjs')
 
 fs.writeFileSync('_result.hpp', cpp)

package/com/cs/test/build.cjs

@@ -1,6 +1,6 @@
 const fs = require('node:fs')
 const cp = require('node:child_process')
-const cs = require('../testlib.f.cjs').result
+const cs = require('../test.f.cjs').result
 
 fs.writeFileSync('_result.cs', cs)
 try {

package/com/rust/module.f.cjs

@@ -29,15 +29,23 @@ const self = ['&self']
 /** @type {(p: types.Field) => string} */
 const paramName = ([n]) => n
 
+/** @type {(p: types.FieldArray) => list.Thunk<string>} */
+const callList = p => map(paramName)(paramList(p))
+
+/** @type {(p: types.FieldArray) => string} */
+const call = p => commaJoin(callList(p))
+
 /** @type {(p: types.FieldArray) => string} */
-const call = p => commaJoin(flat([['self'], map(paramName)(paramList(p))]))
+const virtualCall = p => commaJoin(flat([['self'], callList(p)]))
+
+const super_ = 'super::'
 
 /** @type {(m: types.Method) => string} */
 const assign = ([n]) => `${n}: Self::${n},`
 
 const mapAssign = map(assign)
 
-const super_ = 'super::'
+const this_ = ['this: &Object']
 
 /** @type {(library: types.Library) => text.Block} */
 const rust = library => {
@@ -78,6 +86,14 @@ const rust = library => {
         return `(${params})${resultStr}`
     }
 
+    /** @type {(n: string) => (p: types.FieldArray) => string} */
+    const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`
+
+    /** @type {(m: types.Method) => string} */
+    const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`
+
+    const mapVirtualFn = map(virtualFn)
+
     /** @type {(m: types.Method) => string} */
     const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`
 
@@ -91,35 +107,38 @@ const rust = library => {
         const [n, p] = m
         return [
             `${headerFn(m)} {`,
-            [`unsafe { (self.interface().${n})(${call(p)}) }`],
+            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
             '}'
         ]
     }
 
     const flatMapImplFn = flatMap(implFn)
 
-    /** @type {(i: types.Interface) => (name: string) => text.Block} */
-    const interface_ = ({ interface: i, guid }) => name => {
+    /** @type {(m: types.Method) => text.Block} */
+    const impl = ([n, p]) => {
+        const type = virtualFnType(` ${n}`)(p)
+        return [
+            `${type} {`,
+            [`unsafe { Self::to_cobject(this) }.${n}(${call(p)})`],
+            '}'
+        ]
+    }
 
-        const this_ = ['this: &Object']
+    const flatMapImpl = flatMap(impl)
 
-        /** @type {(m: types.Method) => string} */
-        const virtualFn = ([n, p]) => `${n}: unsafe extern "system" fn${func(this_)(p)}`
+    /** @type {(i: types.Interface) => (name: string) => text.Block} */
+    const interface_ = ({ interface: i, guid }) => name => {
 
         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>;',
+                'pub type Object = nanocom::Object<Interface>;',
+                'pub type Ref = nanocom::Ref<Interface>;',
+                'pub type Vmt = nanocom::Vmt<Interface>;',
             ],
-            rustStruct(map(virtualFn)(e))('Interface'),
+            rustStruct(mapVirtualFn(e))('Interface'),
             [   'impl nanocom::Interface for Interface {',
                 [   `const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`],
                 '}',
@@ -139,6 +158,13 @@ const rust = library => {
                 ],
                 '}',
                 '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'],
+                `{`,
+                flatMapImpl(e),
+                `}`,
+                'impl<T: nanocom::Class<Interface = Interface>> PrivateClassEx for T where nanocom::CObject<T>: Ex {}',
             ],
             '}'
         ]

package/com/rust/test.f.cjs

@@ -3,74 +3,101 @@ const { flat } = require('../../text/module.f.cjs')
 const { join } = require('../../types/string/module.f.cjs')
 const library = require('../types/testlib.f.cjs')
 
-module.exports = () => {
-    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 = {
+    result: () => {
+        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' +
+            '    pub type Object = nanocom::Object<Interface>;\n' +
+            '    pub type Ref = nanocom::Ref<Interface>;\n' +
+            '    pub 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' +
+            '    trait PrivateClassEx: nanocom::Class<Interface = Interface>\n' +
+            '    where\n' +
+            '        nanocom::CObject<Self>: Ex\n' +
+            '    {\n' +
+            '        extern "system" fn GetSlice(this: &Object) -> super::Slice {\n' +
+            '            unsafe { Self::to_cobject(this) }.GetSlice()\n' +
+            '        }\n' +
+            '        extern "system" fn SetSlice(this: &Object, slice: super::Slice) {\n' +
+            '            unsafe { Self::to_cobject(this) }.SetSlice(slice)\n' +
+            '        }\n' +
+            '        extern "system" fn GetUnsafe(this: &Object) -> *const bool {\n' +
+            '            unsafe { Self::to_cobject(this) }.GetUnsafe()\n' +
+            '        }\n' +
+            '        extern "system" fn SetUnsafe(this: &Object, p: *const super::Slice, size: u32) {\n' +
+            '            unsafe { Self::to_cobject(this) }.SetUnsafe(p, size)\n' +
+            '        }\n' +
+            '        extern "system" fn Some(this: &Object, p: &super::IMy::Object) -> bool {\n' +
+            '            unsafe { Self::to_cobject(this) }.Some(p)\n' +
+            '        }\n' +
+            '        extern "system" fn GetIMy(this: &Object) -> super::IMy::Ref {\n' +
+            '            unsafe { Self::to_cobject(this) }.GetIMy()\n' +
+            '        }\n' +
+            '    }\n' +
+            '    impl<T: nanocom::Class<Interface = Interface>> PrivateClassEx for T where nanocom::CObject<T>: Ex {}\n' +
+            '}'
+        const r = join('\n')(flat('    ')(rust(library)))
+        if (r !== e) { throw [e, r] }
+        return r
+    }
+}

package/package.json

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

package/test.mjs

@@ -65,7 +65,7 @@ const load = async () => {
                         await f(file)
                     }
                 } else if (name.endsWith('.f.cjs')) {
-                    console.log(`loading ${file}`)
+                    // console.log(`loading ${file}`)
                     const source = await readFile(file, 'utf8')
                     map.push([file, Function('module', 'require', `"use strict";${source}`)])
                 }
@@ -107,7 +107,7 @@ const build = async () => {
             const module = {
                 dependencies: {}
             }
-            console.log(`${i}building ${pathStr}`)
+            // console.log(`${i}building ${pathStr}`)
             const getModule = req(newBase)(`${i}| `)
             const newReq = s => {
                 const [p, result] = getModule(s)
@@ -130,10 +130,12 @@ const modules = await build()
 
 // graph
 
+/*
 for (const [k, v] of Object.entries(modules)) {
     console.log(`: ${k}`)
     console.log(Object.keys(v.dependencies))
 }
+*/
 
 // test runner.