firefly-compiler 0.5.35 → 0.5.37

package/core/Js.ff

@@ -0,0 +1,305 @@
+// The compiler may decide to access symbols by name instead of going through globalThis
+
+jsSystem(): JsSystem {
+    panic("This call should have been eliminated by the compiler")
+}
+
+import(module: String): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+browserImport(module: String): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+dynamicImport(module: String): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+await(promise: JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async0[R](body: () => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async1[R](body: (JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async2[R](body: (JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async3[R](body: (JsValue, JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async4[R](body: (JsValue, JsValue, JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async5[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async6[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async7[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async8[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+async9[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => JsValue): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+inAsync(): Bool {
+    panic("This call should have been eliminated by the compiler")
+}
+    
+inBrowser(): Bool {
+    panic("This call should have been eliminated by the compiler")
+}
+    
+inNode(): Bool {
+    panic("This call should have been eliminated by the compiler")
+}
+    
+inBuild(): Bool {
+    panic("This call should have been eliminated by the compiler")
+}
+
+currentTask(): Task {
+    panic("This call should have been eliminated by the compiler")
+}
+
+throwIfCancelled(): Unit {
+    panic("This call should have been eliminated by the compiler")
+}
+
+cancelled(): Bool {
+    if(inAsync()) {
+        currentTask().controller->signal->aborted?
+    } else {
+        False
+    }
+}
+
+controller(): JsValue {
+    currentTask().controller
+}
+
+setController(controller: JsValue) {
+    currentTask().controller = controller
+}
+    
+withSignal[T](body: JsValue => T): T {
+    let controller = Js.controller()
+    try {
+        body(controller->signal)
+    } finally {
+        if(controller->signal->aborted?) {Js.setController(Js->AbortController->())}
+    }
+}
+
+awaitCancellablePromise[T](body: (T => Unit, Error => Unit, (Bool => Unit) => Unit) => Unit): T {
+    Js.throwIfCancelled()
+    Js.await(Js->Promise->(Js->{resolve, reject =>
+        mutable settled = False
+        let cleanups = Array.new[Bool => Unit]()
+        let doResolve: T => Unit = {v => 
+            if(!settled) {
+                settled = True
+                try {
+                    cleanups.each {c => c(True)}
+                    resolve.callValue1(v!)
+                } catchAny {e =>
+                    reject.callValue1(e!)
+                }
+            }
+        }
+        let doReject: Error => Unit = {v => 
+            if(!settled) {
+                settled = True
+                try {
+                    cleanups.each {c => c(False)}
+                    reject.callValue1(v!)
+                } catchAny {e =>
+                    reject.callValue1(e!)
+                }            
+            }
+        }
+        let jsReject = Js->{e => doReject(e?)}
+        let controller = Js.controller()
+        controller->signal->addEventListener("abort", jsReject)
+        cleanups.push({_ => controller->signal->removeEventListener("abort", jsReject)})
+        body(doResolve, doReject, {cleanup => cleanups.push(cleanup)})
+    }))?
+}
+
+value[T](value: T): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+fromValue[T](value: JsValue): T {
+    panic("This call should have been eliminated by the compiler")
+}
+
+throw[T](value: JsValue): T {
+    panic("This call should have been eliminated by the compiler")
+}
+
+unaryOperator[T1: IsJsValue](operator: String, a1: T1): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+binaryOperator[T1: IsJsValue, T2: IsJsValue](operator: String, a1: T1, a2: T2): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+shortCircuitingOperator[T1: IsJsValue, T2: IsJsValue](operator: String, a1: T1, a2: () => T2): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+rawIdentifier(operator: String): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+
+globalThis(): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+get(key: String): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+set[V: IsJsValue](key: String, value: V): Unit {
+    panic("This call should have been eliminated by the compiler")
+}
+
+increment[V: IsJsValue](key: String, value: V): Unit {
+    panic("This call should have been eliminated by the compiler")
+}
+
+decrement[V: IsJsValue](key: String, value: V): Unit {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call0(name: String): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call1[A1: IsJsValue](name: String, a1: A1): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call2[A1: IsJsValue, A2: IsJsValue](name: String, a1: A1, a2: A2): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call3[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue](name: String, a1: A1, a2: A2, a3: A3): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call4[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call5[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call6[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call7[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call8[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+call9[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue, A9: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+null(): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+undefined(): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+orUndefined[T: IsJsValue](value: Option[T]): JsValue {
+    value.{
+        | None => Js.undefined()
+        | Some(v) => v!
+    }
+}
+
+object(): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+new0(): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+array(values: List[JsValue]): JsValue {
+    values!
+}
+
+json(value: Json): JsValue {
+    value.jsValue
+}
+
+function0[R](body: () => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function1[R](body: JsValue => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function2[R](body: (JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function3[R](body: (JsValue, JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function4[R](body: (JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function5[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function6[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function7[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function8[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}
+
+function9[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+    panic("This call should have been eliminated by the compiler")
+}

package/core/JsSystem.ff

@@ -1,114 +1,135 @@
-class JsSystem {}
-
-extend self: JsSystem {
-
-    globalThis(): JsValue
-        target js sync "return self_"
-
-    get(key: String): JsValue
-        target js sync "return self_[key_]"
-
-    set[V: IsJsValue](key: String, value: V): Unit
-        target js sync "self_[key_] = value_"
-
-    increment[V: IsJsValue](key: String, value: V): Unit
-        target js sync "self_[key_] += value_"
-        
-    decrement[V: IsJsValue](key: String, value: V): Unit
-        target js sync "self_[key_] -= value_"
-
-    call0(name: String): JsValue
-        target js sync "return self_[name_].call(void 0)"
-
-    call1[A1: IsJsValue](name: String, a1: A1): JsValue
-        target js sync "return self_[name_].call(void 0, a1_)"
-
-    call2[A1: IsJsValue, A2: IsJsValue](name: String, a1: A1, a2: A2): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_)"
-
-    call3[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue](name: String, a1: A1, a2: A2, a3: A3): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_, a3_)"
-
-    call4[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_, a3_, a4_)"
-
-    call5[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_, a3_, a4_, a5_)"
-
-    call6[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_, a3_, a4_, a5_, a6_)"
-
-    call7[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_, a3_, a4_, a5_, a6_, a7_)"
-
-    call8[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_)"
-
-    call9[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue, A9: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): JsValue
-        target js sync "return self_[name_].call(void 0, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_)"
-        
-    parseJson(json: String): JsValue
-        target js sync "return JSON.parse(json_)"
-
-    null(): JsValue
-        target js sync "return null"
-
-    undefined(): JsValue
-        target js sync "return void 0"
-
-    value[T: IsJsValue](jsValue: T): JsValue
-        target js sync "return jsValue_"
-
-    object(): JsValue
-        target js sync "return {}"
-        
-    new0(): JsValue
-        target js sync "return {}"
-
-    array(values: List[JsValue]): JsValue
-        target js sync "return values_.slice()"
-        
-    json(value: Json): JsValue
-        target js sync "return value_"
-
-    function0[R](body: () => R): JsValue
-        target js sync "return body_"
-        target js async "return () => body_($task)"
-
-    function1[R](body: JsValue => R): JsValue
-        target js sync "return body_"
-        target js async "return a1 => body_(a1, $task)"
-
-    function2[R](body: (JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2) => body_(a1, a2, $task)"
-
-    function3[R](body: (JsValue, JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2, a3) => body_(a1, a2, a3, $task)"
-
-    function4[R](body: (JsValue, JsValue, JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2, a3, a4) => body_(a1, a2, a3, a4, $task)"
-
-    function5[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2, a3, a4, a5) => body_(a1, a2, a3, a4, a5, $task)"
-
-    function6[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2, a3, a4, a5, a6) => body_(a1, a2, a3, a4, a5, a6, $task)"
-
-    function7[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2, a3, a4, a5, a6, a7) => body_(a1, a2, a3, a4, a5, a6, a7, $task)"
-
-    function8[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2, a3, a4, a5, a6, a7, a8) => body_(a1, a2, a3, a4, a5, a6, a7, a8, $task)"
-
-    function9[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue
-        target js sync "return body_"
-        target js async "return (a1, a2, a3, a4, a5, a6, a7, a8, a9) => body_(a1, a2, a3, a4, a5, a6, a7, a8, a9, $task)"
-
-}
+class JsSystem {}
+
+// The compiler may decide to access symbols by name instead of going through globalThis
+
+extend self: JsSystem {
+
+    globalThis(): JsValue {
+        Js.globalThis()
+    }
+
+    get(key: String): JsValue {
+        Js.get(key)
+    }
+
+    set[V: IsJsValue](key: String, value: V): Unit {
+        Js.set(key, value)
+    }
+
+    increment[V: IsJsValue](key: String, value: V): Unit {
+        Js.increment(key, value)
+    }
+        
+    decrement[V: IsJsValue](key: String, value: V): Unit {
+        Js.decrement(key, value)
+    }
+
+    call0(name: String): JsValue {
+        Js.call0(name)
+    }
+
+    call1[A1: IsJsValue](name: String, a1: A1): JsValue {
+        Js.call1(name, a1)
+    }
+
+    call2[A1: IsJsValue, A2: IsJsValue](name: String, a1: A1, a2: A2): JsValue {
+        Js.call2(name, a1, a2)
+    }
+
+    call3[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue](name: String, a1: A1, a2: A2, a3: A3): JsValue {
+        Js.call3(name, a1, a2, a3)
+    }
+
+    call4[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4): JsValue {
+        Js.call4(name, a1, a2, a3, a4)
+    }
+
+    call5[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): JsValue {
+        Js.call5(name, a1, a2, a3, a4, a5)
+    }
+
+    call6[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): JsValue {
+        Js.call6(name, a1, a2, a3, a4, a5, a6)
+    }
+
+    call7[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7): JsValue {
+        Js.call7(name, a1, a2, a3, a4, a5, a6, a7)
+    }
+
+    call8[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): JsValue {
+        Js.call8(name, a1, a2, a3, a4, a5, a6, a7, a8)
+    }
+
+    call9[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue, A9: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): JsValue {
+        Js.call9(name, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+    }
+
+    null(): JsValue {
+        Js.null()
+    }
+
+    undefined(): JsValue {
+        Js.undefined()
+    }
+
+    value[T: IsJsValue](jsValue: T): JsValue {
+        Js.value(jsValue)
+    }
+
+    object(): JsValue {
+        Js.object()
+    }
+        
+    new0(): JsValue {
+        Js.new0()
+    }
+
+    array(values: List[JsValue]): JsValue {
+        Js.array(values)
+    }
+
+    json(value: Json): JsValue {
+        Js.json(value)
+    }
+
+    function0[R](body: () => R): JsValue {
+        Js.function0(body)
+    }
+
+    function1[R](body: JsValue => R): JsValue {
+        Js.function1(body)
+    }
+
+    function2[R](body: (JsValue, JsValue) => R): JsValue {
+        Js.function2(body)
+    }
+
+    function3[R](body: (JsValue, JsValue, JsValue) => R): JsValue {
+        Js.function3(body)
+    }
+
+    function4[R](body: (JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+        Js.function4(body)
+    }
+
+    function5[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+        Js.function5(body)
+    }
+
+    function6[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+        Js.function6(body)
+    }
+
+    function7[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+        Js.function7(body)
+    }
+
+    function8[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+        Js.function8(body)
+    }
+
+    function9[R](body: (JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue, JsValue) => R): JsValue {
+        Js.function9(body)
+    }
+
+}