functionalscript 0.3.4 → 0.3.6

package/com/rust/module.f.ts

@@ -1,287 +0,0 @@
-/**
- * This module generates Rust code for COM interop from a high-level type library definition.
- *
- * The module provides functions to define structs, traits, and implementations in Rust,
- * specifically tailored for `nanocom` interoperation.
- */
-import * as types from '../types/module.f.ts'
-const { paramList } = types
-import * as Text from '../../text/module.f.ts'
-import * as O from '../../types/object/module.f.ts'
-import * as list from '../../types/list/module.f.ts'
-const { flat, map, flatMap } = list
-const { entries } = Object
-import * as func from '../../types/function/module.f.ts'
-const { fn } = func
-import * as string from '../../types/string/module.f.ts'
-const { join } = string
-
-const rustField
-    : (field: string) => string
-    = field => `pub ${field},`
-
-const mapRustField = map(rustField)
-
-const rustStruct
-    : (b: list.Thunk<string>) => (name: string) => Text.Block
-    = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`]
-
-const commaJoin = join(', ')
-
-const ref
-    : (name: string) => string
-    = name => `${name}::Ref`
-
-const obj
-    : (name: string) => string
-    = name => `&${name}::Object`
-
-const self = ['&self']
-
-const paramName
-    : (p: types.Field) => string
-    = ([n]) => n
-
-const callList
-    : (p: types.FieldArray) => list.Thunk<string>
-    = p => map(paramName)(paramList(p))
-
-const call
-    : (p: types.FieldArray) => string
-    = p => commaJoin(callList(p))
-
-const virtualCall
-    : (p: types.FieldArray) => string
-    = p => commaJoin(flat([['self'], callList(p)]))
-
-const super_ = 'super::'
-
-const assign
-    : (m: types.Method) => string
-    = ([n]) => `${n}: Self::${n},`
-
-const mapAssign = map(assign)
-
-const this_ = ['this: &Object']
-
-const rustType
-    : (n: string) => string
-    = n => `pub type ${n} = nanocom::${n}<Interface>;`
-
-type OptionalProperty<T> = T|{}
-
-type Where = {readonly where: readonly string[]}
-
-type WhereContent = OptionalProperty<Where> & {readonly content: Text.Block}
-
-const whereContent
-    : (h: string) => (wh: WhereContent) => Text.Block
-    = h => wh => {
-    const w = 'where' in wh ? [
-        h,
-        `where`,
-        mapComma(wh.where),
-        '{'
-    ]: [`${h} {`]
-    const x = [
-        wh.content,
-        '}',
-    ]
-    return flat([w, x])
-}
-
-type Impl = {
-    readonly param?: string
-    readonly trait: string
-    readonly type: string
-    readonly where?: readonly string[]
-    readonly content: Text.Block
-}
-
-const rustImpl
-    : (impl: Impl) => Text.Block
-    = i => {
-    const p = 'param' in i ? `<${i.param}>` : ''
-    const header = `impl${p} ${i.trait} for ${i.type}`
-    return whereContent(header)(i)
-}
-
-type Trait = {
-    readonly pub?: true
-    readonly type: string
-    readonly where?: readonly string[]
-    readonly content: Text.Block
-}
-
-const comma: (s: string) => string = s => `${s},`
-
-const mapComma = map(comma)
-
-const trait
-    : (t: Trait) => Text.Block
-    = t => {
-    const p = t.pub === true ? 'pub ' : ''
-    const h = `${p}trait ${t.type}`
-    return whereContent(h)(t)
-}
-
-const traitImpl
-    : (t: Trait) => Text.Block
-    = t => {
-    const i = rustImpl({
-        param: 'T',
-        trait: t.type,
-        type: 'T',
-        where,
-        content: [],
-    })
-    return flat([trait({ ...t, where }), i])
-}
-
-const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex']
-
-/**
- * Generates Rust code for the given type library.
- *
- * @param library - The library of type definitions to generate Rust code for.
- * @returns A block of Rust code representing the library.
- */
-export const rust = (library: types.Library): Text.Block => {
-
-    const type
-        : (p: string) => (o: (_: string) => string) => (t: types.Type) => string
-        = p => {
-        const f
-            : (o: (_: string) => string) => (t: types.Type) => string
-            = 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 'interface' in library[id] ? o(fullId) : fullId
-        }
-        return f
-    }
-
-    const pf
-        : (p: string) => (o: (_: string) => string) => (f: types.Field) => string
-        = p => o => ([name, t]) => `${name}: ${type(p)(o)(t)}`
-
-    const param = pf(super_)(obj)
-
-    const mapParam = map(param)
-
-    const mapField = map(pf('')(ref))
-
-    const struct
-        : (fa: types.FieldArray) => (name: string) => Text.Block
-        = fn(entries)
-            .then(mapField)
-            .then(rustStruct)
-            .result
-
-    const func
-        : (first: readonly string[]) => (p: types.FieldArray) => string
-        = first => p => {
-        const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : ''
-        const params = commaJoin(flat([first, mapParam(paramList(p))]))
-        return `(${params})${resultStr}`
-    }
-
-    const virtualFnType
-        : (n: string) => (p: types.FieldArray) => string
-        = n => p => `extern "system" fn${n}${func(this_)(p)}`
-
-    const virtualFn
-        : (m: types.Method) => string
-        = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`
-
-    const mapVirtualFn = map(virtualFn)
-
-    const headerFn
-        : (m: types.Method) => string
-        = ([n, p]) => `fn ${n}${func(self)(p)}`
-
-    const traitFn
-        : (m: types.Method) => string
-        = m => `${headerFn(m)};`
-
-    const mapTraitFn = map(traitFn)
-
-    const implFn
-        : (m: types.Method) => Text.Block
-        = m => {
-        const [n, p] = m
-        return [
-            `${headerFn(m)} {`,
-            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
-            '}'
-        ]
-    }
-
-    const flatMapImplFn = flatMap(implFn)
-
-    const impl
-        : (m: types.Method) => Text.Block
-        = ([n, p]) => {
-        const type = virtualFnType(` ${n}`)(p)
-        return [
-            `${type} {`,
-            [`unsafe { nanocom::CObject::from_object_unchecked(this) }.${n}(${call(p)})`],
-            '}'
-        ]
-    }
-
-    const flatMapImpl = flatMap(impl)
-
-    const interface_
-        : (i: types.Interface) => (name: string) => Text.Block
-        = ({ interface: i, guid }) => name => {
-
-        const e = entries(i)
-
-        return [
-            `pub mod ${name} {`,
-            [
-                rustType('Object'),
-                rustType('Ref'),
-                rustType('Vmt'),
-            ],
-            rustStruct(mapVirtualFn(e))('Interface'),
-            rustImpl({
-                trait: 'nanocom::Interface',
-                type: 'Interface',
-                content: [`const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`]
-            }),
-            trait({ pub: true, type: 'Ex', content: mapTraitFn(e) }),
-            rustImpl({
-                trait: 'Ex',
-                type: 'Object',
-                content: flatMapImplFn(e)
-            }),
-            traitImpl({
-                pub: true,
-                type: 'ClassEx',
-                content: ['const VMT: Vmt = Vmt {',
-                    [   'iunknown: nanocom::CObject::<Self>::IUNKNOWN,',
-                        'interface: Interface {',
-                            mapAssign(e),
-                        '},',
-                    ],
-                    '};'
-                ]
-            }),
-            traitImpl({
-                type: 'PrivateClassEx',
-                content: flatMapImpl(e)
-            }),
-            '}'
-        ]
-    }
-
-    const def
-        : (type: O.Entry<types.Definition>) => Text.Block
-        = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name)
-
-    return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))])
-}

package/com/rust/nanocom/Cargo.lock

@@ -1,7 +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/com/rust/nanocom/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "nanocom"
-version = "0.2.1"
-edition = "2021"
-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
-
-[dependencies]

package/com/rust/nanocom/README.md

@@ -1,56 +0,0 @@
-# Nano-COM
-
-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,6 +0,0 @@
-use crate::{Interface, Vmt};
-
-pub trait Class: Sized {
-    type Interface: Interface;
-    fn static_vmt() -> &'static Vmt<Self::Interface>;
-}

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

@@ -1,90 +0,0 @@
-use std::{
-    ptr::null,
-    sync::atomic::{AtomicU32, Ordering},
-};
-
-use crate::{guid::GuidEx, hresult::HRESULT, iunknown::IUnknown, Class, Object, Ref};
-
-#[repr(C)]
-pub struct CObject<T: Class> {
-    object: Object<T::Interface>,
-    counter: AtomicU32,
-    pub value: T,
-}
-
-impl<T: Class> CObject<T> {
-    pub const IUNKNOWN: IUnknown<T::Interface> = IUnknown {
-        QueryInterface: Self::QueryInterface,
-        AddRef: Self::AddRef,
-        Release: Self::Release,
-    };
-
-    pub unsafe fn from_object_unchecked(this: &Object<T::Interface>) -> &CObject<T> {
-        let p = this as *const Object<T::Interface> as *const CObject<T>;
-        &*p
-    }
-
-    #[allow(non_snake_case)]
-    extern "system" fn QueryInterface(
-        this: &Object<T::Interface>,
-        riid: &u128,
-        ppv_object: &mut *const Object,
-    ) -> HRESULT {
-        let (p, r) = if *riid == <()>::PLATFORM_GUID || *riid == T::Interface::PLATFORM_GUID {
-            Self::AddRef(this);
-            (this.to_iunknown() as *const Object, HRESULT::S_OK)
-        } else {
-            (null(), HRESULT::E_NOINTERFACE)
-        };
-        *ppv_object = p;
-        r
-    }
-
-    #[allow(non_snake_case)]
-    extern "system" fn AddRef(this: &Object<T::Interface>) -> u32 {
-        unsafe { Self::from_object_unchecked(this) }
-            .counter
-            .fetch_add(1, Ordering::Relaxed)
-            + 1
-    }
-
-    #[allow(non_snake_case)]
-    extern "system" fn Release(this: &Object<T::Interface>) -> u32 {
-        let t = unsafe { Self::from_object_unchecked(this) };
-        match t.counter.fetch_sub(1, Ordering::Relaxed) {
-            1 => {
-                let m = t as *const CObject<T> as *mut CObject<T>;
-                let _ = unsafe { Box::from_raw(m) };
-                0
-            }
-            x => x - 1,
-        }
-    }
-}
-
-pub trait CObjectEx: Class {
-    fn to_cobject(self) -> Ref<Self::Interface> {
-        let c = CObject {
-            object: Object::new(Self::static_vmt()),
-            counter: Default::default(),
-            value: self,
-        };
-        let p = Box::into_raw(Box::new(c));
-        let o = &unsafe { &*p }.object;
-        o.into()
-    }
-}
-
-impl<T: Class> CObjectEx for T {}
-
-impl<'a, T: Class> From<&'a CObject<T>> for &'a Object<T::Interface> {
-    fn from(this: &'a CObject<T>) -> Self {
-        &this.object
-    }
-}
-
-impl<T: Class> From<&CObject<T>> for Ref<T::Interface> {
-    fn from(this: &CObject<T>) -> Self {
-        (&this.object).into()
-    }
-}

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

@@ -1,15 +0,0 @@
-use crate::Interface;
-
-pub type GUID = u128;
-
-pub trait GuidEx: Interface {
-    const PLATFORM_GUID: GUID = {
-        let x = Self::GUID;
-        (x >> 96)
-            | ((x >> 48) & 0x00000_000_0000_0000_0000_FFFF_0000_0000)
-            | ((x >> 16) & 0x0000_0000_0000_0000_FFFF_0000_0000_0000)
-            | (((x as u64).swap_bytes() as u128) << 64)
-    };
-}
-
-impl<T: Interface> GuidEx for T {}

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

@@ -1,7 +0,0 @@
-#[allow(non_camel_case_types)]
-#[repr(u32)]
-#[derive(Debug)]
-pub enum HRESULT {
-    S_OK = 0,
-    E_NOINTERFACE = 0x80004002,
-}

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

@@ -1,9 +0,0 @@
-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,13 +0,0 @@
-use crate::{hresult::HRESULT, Object, GUID};
-
-#[allow(non_snake_case)]
-#[repr(C)]
-pub struct IUnknown<I: 'static> {
-    pub QueryInterface: unsafe extern "system" fn(
-        this: &Object<I>,
-        riid: &GUID,
-        ppv_object: &mut *const Object,
-    ) -> HRESULT,
-    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/lib.rs

@@ -1,20 +0,0 @@
-mod class;
-mod cobject;
-mod guid;
-mod hresult;
-mod interface;
-mod iunknown;
-mod object;
-mod r#ref;
-mod vmt;
-
-pub use crate::{
-    class::Class,
-    cobject::{CObject, CObjectEx},
-    guid::GUID,
-    interface::Interface,
-    iunknown::IUnknown,
-    object::Object,
-    r#ref::Ref,
-    vmt::Vmt,
-};

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

@@ -1,34 +0,0 @@
-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>);
-
-impl<I> Object<I> {
-    pub fn new(vmt: &'static Vmt<I>) -> Self {
-        Self(vmt)
-    }
-    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 {
-        let p = self as *const Object<I> as *const Object;
-        unsafe { &*p }
-    }
-    pub fn query_interface<J: Interface>(&self) -> Result<Ref<J>, HRESULT> {
-        let mut p = null();
-        match unsafe { (self.0.iunknown.QueryInterface)(self, &J::GUID, &mut p) } {
-            HRESULT::S_OK => {
-                let r = p as *const Object<J>;
-                Ok(unsafe { Ref::from_raw(r) })
-            }
-            e => Err(e),
-        }
-    }
-    pub fn query_iunknown(&self) -> Ref {
-        self.query_interface().unwrap()
-    }
-}

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

@@ -1,57 +0,0 @@
-use std::{
-    cmp::Eq,
-    fmt::{Debug, Formatter},
-    ops::Deref,
-};
-
-use crate::object::Object;
-
-#[repr(transparent)]
-pub struct Ref<I: 'static = ()>(*const Object<I>);
-
-impl<I: 'static> Ref<I> {
-    pub unsafe fn from_raw(p: *const Object<I>) -> Ref<I> {
-        Ref(p)
-    }
-}
-
-impl<I> Deref for Ref<I> {
-    type Target = Object<I>;
-    fn deref(&self) -> &Self::Target {
-        let p = self.0;
-        unsafe { &*p }
-    }
-}
-
-impl<I> Drop for Ref<I> {
-    fn drop(&mut self) {
-        unsafe { (self.iunknown().Release)(self) };
-    }
-}
-
-impl<I> Clone for Ref<I> {
-    fn clone(&self) -> Self {
-        self.deref().into()
-    }
-}
-
-impl<I> From<&Object<I>> for Ref<I> {
-    fn from(this: &Object<I>) -> Self {
-        unsafe { (this.iunknown().AddRef)(this) };
-        Self(this)
-    }
-}
-
-impl<I> Debug for Ref<I> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("Ref").field(&self.0).finish()
-    }
-}
-
-impl<I> PartialEq for Ref<I> {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
-    }
-}
-
-impl<I> Eq for Ref<I> {}

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

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