functionalscript 0.1.608 → 0.2.0

package/nanvm-lib/src/interface.rs

@@ -0,0 +1,136 @@
+use core::fmt;
+
+use crate::{nullish::Nullish, sign::Sign, simple::Simple};
+
+pub trait Container: Clone {
+    type Header;
+    type Item;
+    fn header(&self) -> &Self::Header;
+    /// For now, we use a slice.
+    /// We may change it in the future to support more sophisticated containers.
+    fn items(&self) -> &[Self::Item];
+    fn new(header: Self::Header, items: impl IntoIterator<Item = Self::Item>) -> Self;
+}
+
+pub trait Complex<U: Any>: PartialEq + Sized + Container {
+    fn to_unknown(self) -> U;
+    fn try_from_unknown(u: U) -> Result<Self, U>;
+}
+
+pub trait String16<U: Any<String16 = Self>>:
+    Complex<U> + Container<Header = (), Item = u16>
+{
+}
+
+pub trait BigInt<U: Any<BigInt = Self>>:
+    Complex<U> + Container<Header = Sign, Item = u64>
+{
+}
+
+pub trait Array<U: Any<Array = Self>>: Complex<U> + Container<Header = (), Item = U> {}
+
+pub trait Object<U: Any<Object = Self>>:
+    Complex<U> + Container<Header = (), Item = (U::String16, U)>
+{
+}
+
+pub trait Function<U: Any<Function = Self>>:
+    Complex<U> + Container<Header = u32, Item = u8>
+{
+}
+
+pub trait Any: PartialEq + Sized + Clone + fmt::Debug {
+    type String16: String16<Self>;
+    type BigInt: BigInt<Self>;
+    type Array: Array<Self>;
+    type Object: Object<Self>;
+    type Function: Function<Self>;
+
+    fn pack(u: Unpacked<Self>) -> Self;
+    fn unpack(self) -> Unpacked<Self>;
+
+    fn new_simple(value: Simple) -> Self;
+    fn try_to_simple(&self) -> Option<Simple>;
+
+    fn try_to<C: Complex<Self>>(self) -> Result<C, Self> {
+        C::try_from_unknown(self)
+    }
+
+    fn to_string(self) -> Self::String16 {
+        if let Some(simple) = self.try_to_simple() {
+            return simple.to_string::<Self>()
+        }
+        if let Ok(v) = self.clone().try_to::<Self::String16>() {
+            return v;
+        }
+        if self.clone().try_to::<Self::Array>().is_ok() {
+            return "".to_string16::<Self>()
+        }
+        if self.clone().try_to::<Self::Object>().is_ok() {
+            return "[object Object]".to_string16::<Self>()
+        }
+        // bigint and function
+        todo!()
+    }
+}
+
+#[derive(PartialEq, Debug, Clone)]
+pub enum Unpacked<U: Any> {
+    Nullish(Nullish),
+    Bool(bool),
+    Number(f64),
+    String16(U::String16),
+    BigInt(U::BigInt),
+    Array(U::Array),
+    Object(U::Object),
+    Function(U::Function),
+}
+
+pub trait Extension: Sized {
+    fn to_complex<C: Complex<impl Any> + Container<Header = ()>>(self) -> C
+    where
+        Self: IntoIterator<Item = C::Item>,
+    {
+        C::new((), self)
+    }
+
+    fn to_string16_unknown<U: Any>(self) -> U
+    where
+        Self: IntoIterator<Item = u16>,
+    {
+        self.to_complex::<U::String16>().to_unknown()
+    }
+
+    fn to_array_unknown(self) -> Self::Item
+    where
+        Self: IntoIterator<Item: Any>,
+    {
+        self.to_complex::<<Self::Item as Any>::Array>()
+            .to_unknown()
+    }
+
+    fn to_object_unknown<U: Any>(self) -> U
+    where Self: IntoIterator<Item = (U::String16, U)>
+    {
+        self.to_complex::<U::Object>().to_unknown()
+    }
+}
+
+impl<T> Extension for T {}
+
+// Utf8
+
+pub trait Utf8 {
+    fn to_string16<U: Any>(&self) -> U::String16;
+    fn to_unknown<U: Any>(&self) -> U;
+}
+
+impl Utf8 for str {
+    fn to_string16<U: Any>(&self) -> U::String16 {
+        self.encode_utf16().to_complex()
+    }
+
+    fn to_unknown<U: Any>(&self) -> U {
+        self.to_string16::<U>().to_unknown()
+    }
+}

package/nanvm-lib/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod interface;
+pub mod extension;
+pub mod nullish;
+pub mod sign;
+pub mod naive;
+pub mod simple;
+pub mod nanenum;

package/nanvm-lib/src/naive.rs

@@ -0,0 +1,229 @@
+use core::{fmt, marker::PhantomData};
+use std::rc;
+
+use crate::{interface::{self, Utf8}, nullish::Nullish, sign::Sign, simple::Simple};
+
+pub trait Policy {
+    type Header: PartialEq + fmt::Debug + Clone;
+    type Item: fmt::Debug;
+    fn items_eq(a: &[Self::Item], b: &[Self::Item]) -> bool;
+}
+
+#[derive(Clone)]
+pub struct ValuePolicy<H, T>(PhantomData<(H, T)>);
+
+impl<H: PartialEq + fmt::Debug + Clone, T: PartialEq + fmt::Debug> Policy for ValuePolicy<H, T> {
+    type Header = H;
+    type Item = T;
+    fn items_eq(a: &[Self::Item], b: &[Self::Item]) -> bool {
+        a == b
+    }
+}
+
+#[derive(Clone)]
+pub struct RefPolicy<H, T>(PhantomData<(H, T)>);
+
+impl<H: PartialEq + fmt::Debug + Clone, T: fmt::Debug> Policy for RefPolicy<H, T> {
+    type Header = H;
+    type Item = T;
+    fn items_eq(a: &[Self::Item], b: &[Self::Item]) -> bool {
+        a.as_ptr() == b.as_ptr()
+    }
+}
+
+pub struct Complex<P: Policy> {
+    header: P::Header,
+    items: rc::Rc<[P::Item]>,
+}
+
+impl<P: Policy> Clone for Complex<P> {
+    fn clone(&self) -> Self {
+        Self { header: self.header.clone(), items: self.items.clone() }
+    }
+}
+
+impl<P: Policy> fmt::Debug for Complex<P> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Complex")
+            .field("header", &self.header)
+            .field("items", &self.items)
+            .finish()
+    }
+}
+
+impl<P: Policy> PartialEq for Complex<P> {
+    fn eq(&self, other: &Self) -> bool {
+        self.header == other.header && P::items_eq(&self.items, &other.items)
+    }
+}
+
+impl<P: Policy> interface::Container for Complex<P> {
+    type Header = P::Header;
+    type Item = P::Item;
+    fn items(&self) -> &[Self::Item] {
+        &*self.items
+    }
+    fn header(&self) -> &Self::Header {
+        &self.header
+    }
+    fn new(header: Self::Header, items: impl IntoIterator<Item = Self::Item>) -> Self {
+        Self {
+            header,
+            items: rc::Rc::from_iter(items),
+        }
+    }
+}
+
+// String
+
+pub type String16 = Complex<ValuePolicy<(), u16>>;
+
+impl interface::Complex<Any> for String16 {
+    fn to_unknown(self) -> Any {
+        Any::String16(self)
+    }
+    fn try_from_unknown(u: Any) -> Result<Self, Any> {
+        if let Any::String16(v) = u {
+            Ok(v)
+        } else {
+            Err(u)
+        }
+    }
+}
+
+impl interface::String16<Any> for String16 {}
+
+// BigInt
+
+pub type BigInt = Complex<ValuePolicy<Sign, u64>>;
+
+impl interface::Complex<Any> for BigInt {
+    fn to_unknown(self) -> Any {
+        Any::BigInt(self)
+    }
+    fn try_from_unknown(u: Any) -> Result<Self, Any> {
+        if let Any::BigInt(v) = u {
+            Ok(v)
+        } else {
+            Err(u)
+        }
+    }
+}
+
+impl interface::BigInt<Any> for BigInt {}
+
+// Array
+
+pub type Array = Complex<RefPolicy<(), Any>>;
+
+impl interface::Complex<Any> for Array {
+    fn to_unknown(self) -> Any {
+        Any::Array(self)
+    }
+    fn try_from_unknown(u: Any) -> Result<Self, Any> {
+        if let Any::Array(v) = u {
+            Ok(v)
+        } else {
+            Err(u)
+        }
+    }
+}
+
+impl interface::Array<Any> for Array {}
+
+// Object
+
+pub type Object = Complex<RefPolicy<(), (String16, Any)>>;
+
+impl interface::Complex<Any> for Object {
+    fn to_unknown(self) -> Any {
+        Any::Object(self)
+    }
+    fn try_from_unknown(u: Any) -> Result<Self, Any> {
+        if let Any::Object(v) = u {
+            Ok(v)
+        } else {
+            Err(u)
+        }
+    }
+}
+
+impl interface::Object<Any> for Object {}
+
+// Function
+
+pub type Function = Complex<RefPolicy<u32, u8>>;
+
+impl interface::Complex<Any> for Function {
+    fn to_unknown(self) -> Any {
+        Any::Function(self)
+    }
+
+    fn try_from_unknown(u: Any) -> Result<Self, Any> {
+        if let Any::Function(v) = u {
+            Ok(v)
+        } else {
+            Err(u)
+        }
+    }
+}
+
+impl interface::Function<Any> for Function {}
+
+// Unknown
+
+#[derive(PartialEq, Debug, Clone)]
+pub enum Any {
+    Simple(Simple),
+    String16(String16),
+    BigInt(BigInt),
+    Array(Array),
+    Object(Object),
+    Function(Function),
+}
+
+impl interface::Any for Any {
+    type String16 = String16;
+    type BigInt = BigInt;
+    type Array = Array;
+    type Object = Object;
+    type Function = Function;
+
+    fn new_simple(value: Simple) -> Self {
+        Self::Simple(value)
+    }
+
+    fn try_to_simple(&self) -> Option<Simple> {
+        if let Self::Simple(v) = self {
+            Some(v.clone())
+        } else {
+            None
+        }
+    }
+
+    fn pack(u: interface::Unpacked<Self>) -> Self {
+        match u {
+            interface::Unpacked::Nullish(n) => Self::Simple(Simple::Nullish(n)),
+            interface::Unpacked::Bool(n) => Self::Simple(Simple::Boolean(n)),
+            interface::Unpacked::Number(n) => Self::Simple(Simple::Number(n)),
+            interface::Unpacked::String16(n) => Self::String16(n),
+            interface::Unpacked::BigInt(n) => Self::BigInt(n),
+            interface::Unpacked::Array(n) => Self::Array(n),
+            interface::Unpacked::Object(n) => Self::Object(n),
+            interface::Unpacked::Function(n) => Self::Function(n),
+        }
+    }
+
+    fn unpack(self) -> interface::Unpacked<Self> {
+        match self {
+            Any::Simple(Simple::Nullish(n)) => interface::Unpacked::Nullish(n),
+            Any::Simple(Simple::Boolean(n)) => interface::Unpacked::Bool(n),
+            Any::Simple(Simple::Number(n)) => interface::Unpacked::Number(n),
+            Any::String16(complex) => interface::Unpacked::String16(complex),
+            Any::BigInt(complex) => interface::Unpacked::BigInt(complex),
+            Any::Array(complex) => interface::Unpacked::Array(complex),
+            Any::Object(complex) => interface::Unpacked::Object(complex),
+            Any::Function(complex) => interface::Unpacked::Function(complex),
+        }
+    }
+}

package/nanvm-lib/src/nanenum.rs

@@ -0,0 +1,230 @@
+use core::{marker::PhantomData, mem::forget};
+use std::rc::Rc;
+
+trait Raw64: Clone {
+    /// Number of bits in the packed structure.
+    const BIT_SIZE: u64;
+    /// Moving ownership from `v` to `Self`.`
+    unsafe fn from_raw64(v: u64) -> Self;
+    /// Moving ownership from `self` to `u64`.
+    unsafe fn into_raw64(self) -> u64;
+}
+
+impl<T> Raw64 for Rc<T> {
+    const BIT_SIZE: u64 = 48;
+    unsafe fn from_raw64(v: u64) -> Self {
+        Rc::from_raw(v as _)
+    }
+    unsafe fn into_raw64(self) -> u64 {
+        Rc::into_raw(self) as *const _ as _
+    }
+}
+
+#[derive(Clone)]
+enum NaNEnum<T: Raw64> {
+    Number(f64),
+    Else(T),
+}
+
+const NEGATIVE: u64 = 1 << 63;
+
+const NOT_FINITE: u64 = 0b0111_1111_1111_0000 << 48;
+
+const INFINITY: u64 = NOT_FINITE;
+
+const NEG_INFINITY: u64 = INFINITY | NEGATIVE;
+
+const NAN: u64 = NOT_FINITE | (1 << 51);
+
+const ELSE: u64 = NAN | NEGATIVE;
+
+const ELSE_DATA: u64 = (1 << 51) - 1;
+
+//  INFINITY: 7FF0...
+// -INFINITY: FFF0...
+//  NAN     : 7FF8...
+//  ELSE    : FFF8...
+//  NUMBER  : ...
+
+/// Represents packed implementation of `NaNEnum`.
+///
+/// Note: currently, only `2^51` values are allowed for `Else`.
+///       However, there are `2^53 - 3` are available,
+///       so it's possible to use more than 51 bits in the future.
+struct NaNEnumPack<T: Raw64>(u64, PhantomData<T>);
+
+impl<T: Raw64> NaNEnumPack<T> {
+    fn check(&self, mask: u64) -> bool {
+        self.0 & mask == mask
+    }
+    /// Creates a temporary object that should be `forget` after using.
+    unsafe fn tmp_unpack(&self) -> NaNEnum<T> {
+        if self.check(ELSE) {
+            NaNEnum::Else(T::from_raw64(self.0 & ELSE_DATA))
+        } else {
+            NaNEnum::Number(f64::from_bits(self.0))
+        }
+    }
+    fn unpack(self) -> NaNEnum<T> {
+        let result = unsafe { self.tmp_unpack() };
+        forget(self);
+        result
+    }
+    fn pack(v: NaNEnum<T>) -> Self {
+        assert!(T::BIT_SIZE <= 51);
+        Self(
+            match v {
+                NaNEnum::Number(n) => n.to_bits(),
+                NaNEnum::Else(e) => unsafe { e.into_raw64() | ELSE },
+            },
+            PhantomData,
+        )
+    }
+}
+
+impl<T: Raw64> Clone for NaNEnumPack<T> {
+    fn clone(&self) -> Self {
+        let tmp = unsafe { self.tmp_unpack() };
+        let c = tmp.clone();
+        forget(tmp);
+        Self::pack(c)
+    }
+}
+
+impl<T: Raw64> Drop for NaNEnumPack<T> {
+    fn drop(&mut self) {
+        unsafe { self.tmp_unpack() };
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use core::{mem::{forget, needs_drop}, ptr::null};
+    use std::rc::Rc;
+
+    use crate::nanenum::{Raw64, NEGATIVE, NOT_FINITE};
+
+    use super::{NaNEnum, NaNEnumPack};
+
+    // See https://doc.rust-lang.org/std/mem/fn.needs_drop.html
+
+    trait Dropable {
+        const _A: () = assert!(needs_drop::<Self>());
+    }
+
+    trait NonDropable {
+        const _A: () = assert!(!needs_drop::<Self>());
+    }
+
+    #[test]
+    fn test_f64() {
+        assert_eq!(f64::INFINITY.to_bits(), NOT_FINITE);
+        assert_eq!((f64::NEG_INFINITY).to_bits(), NOT_FINITE | NEGATIVE);
+        assert_eq!(f64::NAN.to_bits(), NOT_FINITE | (1 << 51));
+    }
+
+    #[test]
+    fn test_pack() {
+        static mut I: u64 = 0;
+
+        struct P();
+
+        impl Default for P {
+            fn default() -> Self {
+                unsafe { I += 1 };
+                Self()
+            }
+        }
+
+        impl Clone for P {
+            fn clone(&self) -> Self {
+                Self::default()
+            }
+        }
+
+        impl Drop for P {
+            fn drop(&mut self) {
+                unsafe { I -= 1 };
+            }
+        }
+
+        impl Raw64 for P {
+            const BIT_SIZE: u64 = 0;
+            unsafe fn from_raw64(v: u64) -> Self {
+                Self()
+            }
+            unsafe fn into_raw64(self) -> u64 {
+                forget(self);
+                0
+            }
+        }
+
+        //
+
+        {
+            unsafe { assert_eq!(I, 0) };
+            {
+                let x = P::default();
+                unsafe { assert_eq!(I, 1) };
+                let m = NaNEnum::Else(x);
+                unsafe { assert_eq!(I, 1) };
+                let p = NaNEnumPack::pack(m);
+                unsafe { assert_eq!(I, 1) };
+                let p1 = p.clone();
+                unsafe { assert_eq!(I, 2) };
+                let m1 = p1.unpack();
+                unsafe { assert_eq!(I, 2) };
+                if let NaNEnum::Else(x1) = m1 {
+                    unsafe { assert_eq!(I, 2) };
+                    // assert_ne!(&x as *const _, null())
+                    // assert_ne!(&m as *const _, null())
+                    assert_ne!(&p as *const _, null());
+                    // assert_ne!(&p1 as *const _, null());
+                    // assert_ne!(&m1 as *const _, null());
+                    assert_ne!(&x1 as *const _, null());
+                } else {
+                    panic!()
+                }
+            }
+            unsafe { assert_eq!(I, 0) };
+        }
+
+        //
+
+        {
+            unsafe { assert_eq!(I, 0) };
+            {
+                let x = P::default();
+                unsafe { assert_eq!(I, 1) };
+                let m = NaNEnum::Else(x.clone());
+                unsafe { assert_eq!(I, 2) };
+                let p = NaNEnumPack::pack(m.clone());
+                unsafe { assert_eq!(I, 3) };
+                let p1 = p.clone();
+                unsafe { assert_eq!(I, 4) };
+                let m1 = p1.clone().unpack();
+                unsafe { assert_eq!(I, 5) };
+                if let NaNEnum::Else(x1) = m1.clone() {
+                    unsafe { assert_eq!(I, 6) };
+                    assert_ne!(&x as *const _, null());
+                    assert_ne!(&m as *const _, null());
+                    assert_ne!(&p as *const _, null());
+                    assert_ne!(&p1 as *const _, null());
+                    assert_ne!(&m1 as *const _, null());
+                    assert_ne!(&x1 as *const _, null());
+                } else {
+                    panic!()
+                }
+            }
+            unsafe { assert_eq!(I, 0) };
+        }
+    }
+
+    #[test]
+    fn test_ptr() {
+        let x = Rc::new("hello");
+        let m = NaNEnum::Else(x);
+        let p = NaNEnumPack::pack(m);
+        let p1 = p.clone();
+    }
+}

package/nanvm-lib/src/nullish.rs

@@ -0,0 +1,7 @@
+/// https://developer.mozilla.org/en-US/docs/Glossary/Nullish
+/// "In JavaScript, a nullish value is the value which is either null or undefined. Nullish values are always falsy."
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum Nullish {
+    Null,
+    Undefined,
+}

package/nanvm-lib/src/sign.rs

@@ -0,0 +1,5 @@
+#[derive(PartialEq, Debug, Clone)]
+pub enum Sign {
+    Positive = 1,
+    Negative = -1,
+}

package/nanvm-lib/src/simple.rs

@@ -0,0 +1,32 @@
+use crate::{
+    interface::{Any, Utf8},
+    nullish::Nullish,
+};
+
+#[derive(PartialEq, Debug, Clone)]
+pub enum Simple {
+    Nullish(Nullish),
+    Boolean(bool),
+    Number(f64),
+}
+
+impl Simple {
+    pub fn to_unknown<U: Any>(self) -> U {
+        U::new_simple(self)
+    }
+    pub fn to_string<U: Any>(self) -> U::String16 {
+        match self {
+            Simple::Nullish(v) => (match v {
+                Nullish::Null => "null",
+                Nullish::Undefined => "undefined",
+            })
+            .to_string16::<U>(),
+            Simple::Boolean(v) => (match v {
+                true => "true",
+                false => "false",
+            })
+            .to_string16::<U>(),
+            Simple::Number(_) => todo!(),
+        }
+    }
+}

package/nanvm-lib/tests/test.f.d.mts

@@ -0,0 +1,36 @@
+declare namespace _default {
+    namespace eq {
+        function nullish(): void;
+        namespace boolean {
+            export function boolean_1(): void;
+            export { boolean_1 as boolean };
+            export function nullish_1(): void;
+            export { nullish_1 as nullish };
+        }
+        namespace number {
+            export function number_1(): void;
+            export { number_1 as number };
+            export function nullish_2(): void;
+            export { nullish_2 as nullish };
+        }
+        namespace string {
+            export function string_1(): void;
+            export { string_1 as string };
+            export function number_2(): void;
+            export { number_2 as number };
+        }
+        namespace bigint {
+            export function bigint_1(): void;
+            export { bigint_1 as bigint };
+        }
+        namespace array {
+            export function array_1(): void;
+            export { array_1 as array };
+        }
+        namespace object {
+            export function object_1(): void;
+            export { object_1 as object };
+        }
+    }
+}
+export default _default;