firefly-compiler 0.5.35 → 0.5.37

package/core/Atomic.ff

@@ -1,64 +1,63 @@
-class Atomic[T] {}
-
-new[T](value: T): Atomic[T]
-    target js sync """
-        return {value: value_}
-    """
-
-extend self[T]: Atomic[T] {
-
-    modify(body: T => T): T
-        target js sync """
-            return self_.value = body_(self_.value)
-        """
-        target js async """
-            let currentValue, newValue
-            do {
-                currentValue = self_.value
-                newValue = await body_(currentValue)
-            } while(currentValue !== self_.value)
-            self_.value = newValue
-            return newValue
-        """
-
-    getAndModify(body: T => T): T
-        target js sync """
-            const currentValue = self_.value
-            self_.value = body_(currentValue)
-            return currentValue
-        """
-        target js async """
-            let currentValue, newValue
-            do {
-                currentValue = self_.value
-                newValue = await body_(currentValue)
-            } while(currentValue !== self_.value)
-            self_.value = newValue
-            return currentValue
-        """
-
-    get(): T
-        target js sync """
-            return self_.value
-        """
-
-    set(value: T): Unit
-        target js sync """
-            self_.value = value
-        """
-
-    getAndSet(newValue: T): T
-        target js sync """
-            const currentValue = self_.value
-            self_.value = newValue
-            return currentValue
-        """
-
-    compareAndSet(currentValue: T, newValue: T): Bool
-        target js sync """
-            if(self_.value !== currentValue) return false
-            self_.value = newValue
-            return true
-        """
-
-}
+class Atomic[T] {}
+
+new[T](value: T): Atomic[T] {
+    Js->(value = value!)?
+}
+
+extend self[T]: Atomic[T] {
+
+    modify(body: T => T): T {
+        if(Js.inAsync()) {
+            mutable currentValue = self!->value
+            mutable newValue = body(self!->value?)
+            while {currentValue !== self!->value} {
+                currentValue = self!->value
+                newValue = body(self!->value?)
+            }
+            self!->value = newValue!
+            newValue
+        } else {
+            let newValue = body(self!->value?)
+            self!->value = newValue!
+            newValue
+        }
+    }
+
+    getAndModify(body: T => T): T {
+        mutable currentValue = self!->value
+        if(Js.inAsync()) {
+            mutable newValue = body(self!->value?)
+            while {currentValue !== self!->value} {
+                currentValue = self!->value
+                newValue = body(self!->value?)
+            }
+            self!->value = newValue!
+            currentValue?
+        } else {
+            let newValue = body(self!->value?)
+            self!->value = newValue!
+            currentValue?
+        }
+    }
+
+    get(): T {
+        self!->value?
+    }
+
+    set(value: T): Unit {
+        self!->value = value!
+    }
+
+    getAndSet(newValue: T): T {
+        let currentValue = self!->value
+        self!->value = newValue!
+        currentValue?
+    }
+
+    compareAndSet(currentValue: T, newValue: T): Bool {
+        if(self!->value !== currentValue!) {False} else:
+        self!->value = newValue!
+        True
+    }
+
+}

package/core/Box.ff

@@ -1,7 +1,7 @@
-class Box[T](mutable value: T)
-
-extend self[T]: Box[T] {
-    modify(body: T => T): Unit {
-        self.value = body(self.value)
-    }
-}
+class Box[T](mutable value: T)
+
+extend self[T]: Box[T] {
+    modify(body: T => T): Unit {
+        self.value = body(self.value)
+    }
+}

package/core/BrowserSystem.ff

@@ -1,40 +1,40 @@
-capability BrowserSystem {}
-
-extend self: BrowserSystem {
-
-    httpClient(): HttpClient
-        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
-    
-    mainTask(): Task
-        target js async "return self_.task_"
-
-    crypto(): Crypto
-        target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
-        
-    js(): JsSystem
-        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
-        
-    url(): String
-        target js async """
-            return location.href;
-        """
-    
-    urlPath(): String
-        target js async """
-            return location.pathname;
-        """
-
-    urlQuery(name: String): Option[String]
-        target js async """
-            const param = new URLSearchParams(location.search).get(name_)
-            if(param == null) return ff_core_Option.None();
-            return ff_core_Option.Some(param);
-        """
-
-    urlFragment(): Option[String]
-        target js async """
-            if(!location.hash.startsWith('#')) return ff_core_Option.None();
-            return ff_core_Option.Some(location.hash.slice(1));
-        """
-               
-}
+capability BrowserSystem {}
+
+extend self: BrowserSystem {
+
+    httpClient(): HttpClient {
+        Js.globalThis()?
+    }
+    
+    mainTask(): Task {
+        self!->"task_"?
+    }
+
+    crypto(): Crypto {
+        Js->crypto?
+    }
+        
+    js(): JsSystem {
+        Js.globalThis()?
+    }
+        
+    url(): String {
+        Js->location->href?
+    }
+    
+    urlPath(): String {
+        Js->location->pathname?
+    }
+
+    urlQuery(name: String): Option[String] {
+        let param = Js->URLSearchParams->(Js->location->search)->get(name)
+        if(param.isNullOrUndefined()) {None} else:
+        Some(param?)
+    }
+
+    urlFragment(): Option[String] {
+        if(!Js->location->hash->startsWith("#")?) {None} else:
+        Some(Js->location->hash->slice(1)?)
+    }
+                 
+}

package/core/Buffer.ff

@@ -1,7 +1,8 @@
 class Buffer {}
 
-new(size: Int, shared: Bool = False): Buffer
-    target js sync "return new DataView(shared_ ? new SharedArrayBuffer(size_) : new ArrayBuffer(size_))"
+new(size: Int, shared: Bool = False): Buffer {
+    Js->DataView->(if(shared) {Js->SharedArrayBuffer->(size)} else {Js->ArrayBuffer->(size)})?
+}
 
 extend self: Buffer {
 
@@ -11,47 +12,57 @@ extend self: Buffer {
     /*grabBigUint64(byteOffset: Int, littleEndian: Bool = True): BigInt
         target js sync "return self_.getBigUint64(byteOffset_, littleEndian_)"*/
 
-    grabUint64(byteOffset: Int, littleEndian: Bool = True): Int
-        target js sync """
-            const high = self_.getUint32(byteOffset_ + (littleEndian_ ? 4 : 0), littleEndian_)
-            const low = self_.getUint32(byteOffset_ + (littleEndian_ ? 0 : 4), littleEndian_)
-            const result = (high * 0x100000000) + low
-            if(!Number.isSafeInteger(result)) throw 'grabUint64 out of range (consider grabBigUint64)'
-            return result
-        """
-
-    grabInt64(byteOffset: Int, littleEndian: Bool = True): Int
-        target js sync """
-            const high = self_.getInt32(byteOffset_ + (littleEndian_ ? 4 : 0), littleEndian_)
-            const low = self_.getUint32(byteOffset_ + (littleEndian_ ? 0 : 4), littleEndian_)
-            const result = (high * 0x100000000) + low
-            if(!Number.isSafeInteger(result)) throw 'grabInt64 out of range (consider grabBigInt64)'
-            return result
-        """
-
-    grabFloat32(byteOffset: Int, littleEndian: Bool = True): Float
-        target js sync "return self_.getFloat32(byteOffset_, littleEndian_)"
+    grabUint64(byteOffset: Int, littleEndian: Bool = True): Int {
+        let high = self!->getUint32(byteOffset + if(littleEndian) {4} else {0}, littleEndian)
+        let low = self!->getUint32(byteOffset + if(littleEndian) {0} else {4}, littleEndian)
+        let result = (high? * 0x100000000) + low?
+        if(!Js->Number->isSafeInteger(result)?) {
+            throw(GrabException)
+        }
+        result
+    }
+    
+    grabInt64(byteOffset: Int, littleEndian: Bool = True): Int {
+        let high = self!->getInt32(byteOffset + if(littleEndian) {4} else {0}, littleEndian)
+        let low = self!->getUint32(byteOffset + if(littleEndian) {0} else {4}, littleEndian)
+        let result = (high? * 0x100000000) + low?
+        if(!Js->Number->isSafeInteger(result)?) {
+            throw(GrabException()) //grabInt64 out of range (consider grabBigInt64)'
+        }
+        result
+    }
 
-    grabFloat64(byteOffset: Int, littleEndian: Bool = True): Float
-        target js sync "return self_.getFloat64(byteOffset_, littleEndian_)"
+    grabFloat32(byteOffset: Int, littleEndian: Bool = True): Float {
+        self!->getFloat32(byteOffset, littleEndian)?
+    }
+    
+    grabFloat64(byteOffset: Int, littleEndian: Bool = True): Float {
+        self!->getFloat64(byteOffset, littleEndian)?
+    }
 
-    grabInt16(byteOffset: Int, littleEndian: Bool = True): Int
-        target js sync "return self_.getInt16(byteOffset_, littleEndian_)"
+    grabInt16(byteOffset: Int, littleEndian: Bool = True): Int {
+        self!->getInt16(byteOffset, littleEndian)?
+    }
 
-    grabInt32(byteOffset: Int, littleEndian: Bool = True): Int
-        target js sync "return self_.getInt32(byteOffset_, littleEndian_)"
+    grabInt32(byteOffset: Int, littleEndian: Bool = True): Int {
+        self!->getInt32(byteOffset, littleEndian)?
+    }
 
-    grabInt8(byteOffset: Int): Int
-        target js sync "return self_.getInt8(byteOffset_)"
+    grabInt8(byteOffset: Int): Int {
+        self!->getInt8(byteOffset)?
+    }
 
-    grabUint16(byteOffset: Int, littleEndian: Bool = True): Int
-        target js sync "return self_.getUint16(byteOffset_, littleEndian_)"
+    grabUint16(byteOffset: Int, littleEndian: Bool = True): Int {
+        self!->getUint16(byteOffset, littleEndian)?
+    }
 
-    grabUint32(byteOffset: Int, littleEndian: Bool = True): Int
-        target js sync "return self_.getUint32(byteOffset_, littleEndian_)"
+    grabUint32(byteOffset: Int, littleEndian: Bool = True): Int {
+        self!->getUint32(byteOffset, littleEndian)?
+    }
 
-    grabUint8(byteOffset: Int): Int
-        target js sync "return self_.getUint8(byteOffset_)"
+    grabUint8(byteOffset: Int): Int {
+        self!->getUint8(byteOffset)?
+    }
 
     /*setBigInt64(byteOffset: Int, value: BigInt, littleEndian: Bool = False): Unit
         target js sync "self_.setBigInt64(byteOffset_, value_, littleEndian_)"*/
@@ -59,121 +70,132 @@ extend self: Buffer {
     /*setBigUint64(byteOffset: Int, value: BigInt, littleEndian: Bool = False): Unit
         target js sync "self_.setBigUint64(byteOffset_, value_, littleEndian_)"*/
 
-    setUint64(byteOffset: Int, value: Int, littleEndian: Bool = True): Int
-        target js sync """
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 4 : 0), (value_ >>> 16) >>> 16, littleEndian_)
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 0 : 4), value_ & 0xffffffff, littleEndian_)
-        """
-
-    setInt64(byteOffset: Int, value: Int, littleEndian: Bool = True): Int
-        target js sync """
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 4 : 0), (value_ >> 16) >> 16, littleEndian_)
-            self_.setUint32(byteOffset_ + (littleEndian_ ? 0 : 4), value_ & 0xffffffff, littleEndian_)
-        """
+    setUint64(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit {
+        self!->setUint32(byteOffset + if(littleEndian) {4} else {0}, value.bitRightUnsigned(16).bitRightUnsigned(16), littleEndian)
+        self!->setUint32(byteOffset + if(littleEndian) {0} else {4}, value.bitAnd(0xffffffff), littleEndian)
+    }
+        
+    setInt64(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit {
+        self!->setUint32(byteOffset + if(littleEndian) {4} else {0}, value.bitRight(16).bitRight(16), littleEndian)
+        self!->setUint32(byteOffset + if(littleEndian) {0} else {4}, value.bitAnd(0xffffffff), littleEndian)
+    }
 
-    setFloat32(byteOffset: Int, value: Float, littleEndian: Bool = True): Unit
-        target js sync "self_.setFloat32(byteOffset_, value_, littleEndian_)"
+    setFloat32(byteOffset: Int, value: Float, littleEndian: Bool = True): Unit {
+        self!->setFloat32(byteOffset, value, littleEndian)
+    }
 
-    setFloat64(byteOffset: Int, value: Float, littleEndian: Bool = True): Unit
-        target js sync "self_.setFloat64(byteOffset_, value_, littleEndian_)"
+    setFloat64(byteOffset: Int, value: Float, littleEndian: Bool = True): Unit {
+        self!->setFloat64(byteOffset, value, littleEndian)
+    }
 
-    setInt16(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
-        target js sync "self_.setInt16(byteOffset_, value_, littleEndian_)"
+    setInt16(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit {
+        self!->setInt16(byteOffset, value, littleEndian)
+    }
 
-    setInt32(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
-        target js sync "self_.setInt32(byteOffset_, value_, littleEndian_)"
+    setInt32(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit {
+        self!->setInt32(byteOffset, value, littleEndian)
+    }
 
-    setInt8(byteOffset: Int, value: Int): Unit
-        target js sync "self_.setInt8(byteOffset_, value_)"
+    setInt8(byteOffset: Int, value: Int): Unit {
+        self!->setInt8(byteOffset, value)
+    }
 
-    setUint16(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
-        target js sync "self_.setUint16(byteOffset_, value_, littleEndian_)"
+    setUint16(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit {
+        self!->setUint16(byteOffset, value, littleEndian)
+    }
 
-    setUint32(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
-        target js sync "self_.setUint32(byteOffset_, value_, littleEndian_)"
+    setUint32(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit {
+        self!->setUint32(byteOffset, value, littleEndian)
+    }
 
-    setUint8(byteOffset: Int, value: Int): Unit
-        target js sync "self_.setUint8(byteOffset_, value_)"
+    setUint8(byteOffset: Int, value: Int): Unit {
+        self!->setUint8(byteOffset, value)
+    }
 
-    setAll(byteOffset: Int, buffer: Buffer): Unit
-        target js sync """
-            const sourceBuffer = new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength)
-            const targetBuffer = new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength)
-            targetBuffer.set(sourceBuffer, byteOffset_)
-        """
+    setAll(byteOffset: Int, buffer: Buffer): Unit {
+        let sourceBuffer = Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength)
+        let targetBuffer = Js->Uint8Array->(self!->buffer, self!->byteOffset, self!->byteLength)
+        targetBuffer->set(sourceBuffer, byteOffset)
+    }
 
-    size(): Int
-        target js sync "return self_.byteLength"
+    size(): Int {
+        self!->byteLength?
+    }
 
-    shared(): Bool
-        target js sync "return typeof SharedArrayBuffer !== 'undefined' && self_.buffer instanceof SharedArrayBuffer"
+    shared(): Bool {
+        Js->SharedArrayBuffer.typeof() != "undefined" && self!->buffer.instanceof(Js->SharedArrayBuffer)
+    }
 
-    view(begin: Int, end: Int): Buffer
-        target js sync "return new DataView(self_.buffer, self_.byteOffset + begin_, end_ - begin_)"
+    view(begin: Int, end: Int): Buffer {
+        Js->DataView->(self!->buffer, self!->byteOffset + begin!, end - begin)?
+    }
 
-    copy(): Buffer
-        target js sync "return new DataView(self_.buffer.slice(self_.byteOffset, self_.byteOffset + self_.byteLength))"
+    copy(): Buffer {
+        Js->DataView->(self!->buffer->slice(self!->byteOffset, self!->byteOffset + self!->byteLength))?
+    }
 
-    toString(encoding: String = "utf8"): String
-        target js sync """
-            if(encoding_ === "utf8") {
-                if(typeof TextDecoder.ffSingleton === 'undefined') TextDecoder.ffSingleton = new TextDecoder()
-                return TextDecoder.ffSingleton.decode(self_)
+    toString(encoding: String = "utf8"): String {
+        if(encoding == "utf8") {
+            if(Js->TextDecoder->ffSingleton.typeof() == "undefined") {
+                Js->TextDecoder->ffSingleton = Js->TextDecoder->()
             }
-            return new TextDecoder().decode(self_)
-        """
+            Js->TextDecoder->ffSingleton->decode(self!)?
+        }
+        Js->TextDecoder->()->decode(self!)?
+    }
 
-    toByteArray(): List[Int]
-        target js sync "return [...new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength)]"
+    toByteArray(): List[Int] {
+        Js->Uint8Array->(self!->buffer, self!->byteOffset, self!->byteLength).spreadToArray()!?
+    }
+    
+    toHex(): String {
+        mutable hex = ""
+        0.until(self!->byteLength?).each {i =>
+            hex = hex + self!->getUint8(i)->toString(16)->padStart(2, "0")?
+        }
+        hex
+    }
+    
+    toBase64(): String {
+        let view = Js->Uint8Array->(self!->buffer, self!->byteOffset, self!->byteLength)
+        let binaryString = Js->TextDecoder->("latin1")->decode(view)
+        Js->btoa(binaryString)?
+    }
 
-    toHex(): String
-        target js sync """
-            let hex = ''
-            for (let i = 0; i < self_.byteLength; i++) {
-                hex += self_.getUint8(i).toString(16).padStart(2, '0')
-            }
-            return hex
-        """
+}
 
-    toBase64(): String
-        target js sync """
-            const view = new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength);
-            return btoa(String.fromCharCode(...view));
-        """
+fromByteList(array: List[Int]): Buffer {
+    Js->DataView->(Js->Uint8Array(array)->buffer)?
+}
 
+fromBufferList(array: List[Buffer]): Buffer {
+    mutable length = 0
+    array.each {length += _!->byteLength?}
+    let arrayBuffer = Js->ArrayBuffer->(length)
+    let result = Js->Uint8Array->(arrayBuffer)
+    mutable offset = 0
+    array.each {b =>
+        result->set(Js->Uint8Array->(b!->buffer, b!->byteOffset, b!->byteLength), offset)
+        offset += b!->byteLength?
+    }
+    Js->DataView->(arrayBuffer)?
 }
 
-fromByteList(array: List[Int]): Buffer
-    target js sync "return new DataView(new Uint8Array(array_).buffer)"
-
-fromBufferList(array: List[Buffer]): Buffer
-    target js sync """
-        let length = 0
-        for(let b of array_) length += b.byteLength
-        const arrayBuffer = new ArrayBuffer(length);
-        const result = new Uint8Array(arrayBuffer)
-        let offset = 0
-        for(let b of array_) {
-            result.set(new Uint8Array(b.buffer, b.byteOffset, b.byteLength), offset)
-            offset += b.byteLength
-        }
-        return new DataView(arrayBuffer)
-    """
-
-fromHex(hex: String): Buffer
-    target js sync """
-        const hexValues = hex_.match(/.{1,2}/g) || []
-        const numbers = hexValues.map(value => parseInt(value, 16))
-        return new DataView(new Uint8Array(numbers).buffer)
-    """
-
-fromBase64(base64: String): Buffer
-    target js sync """
-        const binaryString = atob(base64_)
-        const dataView = new DataView(new ArrayBuffer(binaryString.length))
-        dataView.setUint8(binaryString.split('').map(char => char.charCodeAt(0)))
-        return dataView
-    """
+fromHex(hex: String): Buffer {
+    let byteCount = (hex.size() * 0.5).ceil().toInt()
+    let arrayBuffer = Js->ArrayBuffer->(byteCount)
+    let result = Js->Uint8Array->(arrayBuffer)
+    0.until(byteCount).each {i =>
+        result.set(i, Js->parseInt(hex!->slice(i * 2, i * 2 + 2), 16))
+    }
+    Js->DataView->(arrayBuffer)?
+}
+
+fromBase64(base64: String): Buffer {
+    let binaryString = Js->atob(base64)
+    let bytes = Js->Uint8Array->from(binaryString, Js->{char => char->CharCodeAt(0)})
+    Js->DataView->(bytes->buffer)?
+}
 
 instance Buffer: Show {
     show(value: Buffer): String {
@@ -182,30 +204,41 @@ instance Buffer: Show {
 }
 
 instance Buffer: Equal {
-    equals(x: Buffer, y: Buffer): Bool
-        target js sync """
-            if(x_.buffer.byteLength !== y_.buffer.byteLength) return false
-            if(x_.buffer === y_.buffer) return true
-            for(let i = 0; i + 4 <= x_.buffer.byteLength; i += 4) {
-                if(x_.getInt32(i) !== y_.getInt32(i)) return false
-            }
-            for(; i < x_.buffer.byteLength; i++) {
-                if(x_.getUint8(i) !== y_.getUint8(i)) return false
-            }
-            return true
-        """
+    equals(x: Buffer, y: Buffer): Bool {
+        if(x.size() != y.size()) {False} else:
+        if(x! === y!) {True} else:
+        mutable i = 0
+        mutable same = True
+        while {i + 4 < x.size() && same} {
+            same = x!->getInt32(i) === y!->getInt32(i)
+            i += 4
+        }
+        if(!same) {False} else:
+        i.until(x.size()).eachWhile {i =>
+            same = x!->getUint8(i) === y!->getUint8(i)
+            same
+        }
+        same
+    }
 }
 
 instance Buffer: Order {
-    compare(x: Buffer, y: Buffer): Ordering
-        target js sync """
-            if(x_.buffer === y_.buffer) return ff_core_Ordering.OrderingSame()
-            const minLength = Math.min(x_.buffer.byteLength, y_.buffer.byteLength)
-            for(let i = 0; i < minLength; i++) {
-                if(x_.getUint8(i) !== y_.getUint8(i)) {
-                    return ff_core_Ordering.fromInt_(x_.getUint8(i) - y_.getUint8(i))
-                }
+    compare(x: Buffer, y: Buffer): Ordering {
+        if(x!.equals(y!)) {OrderingSame} else:
+        let minLength = x.size().min(y.size())
+        mutable ordering = OrderingSame
+        0.until(minLength).eachWhile {i =>
+            if(x!->getUint8(i) !== x!->getUint8(i)) {
+                ordering = Ordering.fromInt((x!->getUint8(i) - y!->getUint8(i))?)
+                False
+            } else {
+                True
             }
-            return ff_core_Ordering.fromInt_(x_.buffer.byteLength - y_.buffer.byteLength)
-        """
+        }
+        if(ordering == OrderingSame) {
+            Ordering.fromInt(x.size() - y.size())
+        } else {
+            ordering
+        }
+    }
 }