firefly-compiler 0.5.6 → 0.5.8

package/compiler/JsEmitter.ff

@@ -160,7 +160,8 @@ extend self: JsEmitter {
     emitLetDefinition(definition: DLet, mutable: Bool, async: Bool): String {
         let mutability = if(mutable) {"let"} else {"const"}
         let valueCode = self.emitTerm(definition.value, async)
-        mutability + " " + escapeKeyword(definition.name) + " = " + valueCode + ";"
+        let assignmentCode = if(valueCode != "(void 0)") {" = " + valueCode} else {""}
+        mutability + " " + escapeKeyword(definition.name) + assignmentCode + ";"
     }
 
     emitExtendsDefinition(definition: DExtend): String {
@@ -352,80 +353,10 @@ extend self: JsEmitter {
             let c = if(await) {", $task"} else {""}
             let call = "(" + self.emitTerm(function, async) + ")(" + self.emitTerm(value, async) + c + ")"
             if(await) {"(await " + call + ")"} else {call}
-        | ECall(at, StaticCall(operator, _, _), _, [], [value], _) {!operator.grabFirst().isAsciiLetter()} =>
-            "(" + operator + self.emitArgument(at, value, async) + ")"
-        | ECall(at, StaticCall(operator, _, _), _, [], [left, right], _) {!operator.grabFirst().isAsciiLetter()} =>
-            "(" + self.emitArgument(at, left, async) + " " + operator + " " + self.emitArgument(at, right, async) + ")"
-        | ECall(at, StaticCall("ff:core/List.List_grab", _, _), _, _, [Argument(_, _, EVariable(_, x1)), Argument(_, _, EVariable(_, x2))], _) =>
-            "(" + escapeResolved(x1) + "[" + escapeResolved(x2) + "] ?? " + 
-            "ff_core_List.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
-        | ECall(at, StaticCall("ff:core/Array.Array_grab", _, _), _, _, [Argument(_, _, EVariable(_, x1)), Argument(_, _, EVariable(_, x2))], _) =>
-            "(" + escapeResolved(x1) + ".array[" + escapeResolved(x2) + "] ?? " + 
-            "ff_core_Array.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
-        | ECall(at, StaticCall("ff:core/UnsafeJs.import", _, _), _, _, [Argument(_, _, EString(_, url))], _) =>
-            self.jsImporter.add(url.replace("\"", ""))
-        | ECall(at, StaticCall("ff:core/UnsafeJs.await", _, _), _, _, [Argument(_, _, body)], _) =>
-            if(async) {
-                "(await " + self.emitTerm(body, async) + "($task))"
-            } else {
-                self.emitTerm(invokeImmediately(body), async)
-            }
-        | ECall(at, StaticCall("ff:core/UnsafeJs.cancelled", _, _), _, _, [], _) =>
-            if(async) {"$task.controller.signal.aborted"} else {"false"}
-        | ECall(at, StaticCall("ff:core/UnsafeJs.throwIfCancelled", _, _), _, _, [], _) =>
-            if(async) {"((() => ff_core_Task.Task_throwIfAborted($task))())"} else {""}
-        | ECall(at, StaticCall("ff:core/UnsafeJs.inAsync", _, _), _, _, [], _) =>
-            if(self.emittingAsync) {"true"} else {"false"}
-        | ECall(at, StaticCall("ff:core/UnsafeJs.inBrowser", _, _), _, _, [], _) =>
-            if(self.emitTarget == EmitBrowser) {"true"} else {"false"}
-        | ECall(at, StaticCall("ff:core/UnsafeJs.inNode", _, _), _, _, [], _) =>
-            if(self.emitTarget == EmitNode) {"true"} else {"false"}
-        | ECall(at, StaticCall("ff:core/UnsafeJs.inBuild", _, _), _, _, [], _) =>
-            if(self.emitTarget == EmitBuild) {"true"} else {"false"}
-        | ECall(at, StaticCall("ff:core/UnsafeJs.value", _, _), _, _, [Argument(_, _, e)], _) =>
-            self.emitTerm(e, async)
-        | ECall(at, StaticCall("ff:core/UnsafeJs.fromValue", _, _), _, _, [Argument(_, _, e)], _) =>
-            self.emitTerm(e, async)
-        | ECall(at, StaticCall("ff:core/Equal.equals", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
-            primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
-        } =>
-            "(" + self.emitArgument(at, left, async) + " === " + self.emitArgument(at, right, async) + ")"
-        | ECall(at, StaticCall("ff:core/Equal.notEquals", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
-            primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
-        } =>
-            "(" + self.emitArgument(at, left, async) + " !== " + self.emitArgument(at, right, async) + ")"
-        | ECall(at, StaticCall("ff:core/Ordering.before", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
-            primitiveTypes.contains(typeName)
-        } =>
-            "(" + self.emitArgument(at, left, async) + " < " + self.emitArgument(at, right, async) + ")"
-        | ECall(at, StaticCall("ff:core/Ordering.notBefore", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
-            primitiveTypes.contains(typeName)
-        } =>
-            "(" + self.emitArgument(at, left, async) + " >= " + self.emitArgument(at, right, async) + ")"
-        | ECall(at, StaticCall("ff:core/Ordering.after", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
-            primitiveTypes.contains(typeName)
-        } =>
-            "(" + self.emitArgument(at, left, async) + " > " + self.emitArgument(at, right, async) + ")"
-        | ECall(at, StaticCall("ff:core/Ordering.notAfter", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
-            primitiveTypes.contains(typeName)
+        | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
+            self.emitSpecialCall(term, async, name, arguments.map {_.value}, dictionaries) | Some(code)
         } =>
-            "(" + self.emitArgument(at, left, async) + " <= " + self.emitArgument(at, right, async) + ")"
-        | ECall(_, StaticCall("ff:core/List.fillBy", _, _), effect, _, [size, Argument(_, _, ELambda(at,
-            Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)@c])@l
-        ))], _) {
-            !effectTypeIsAsync(effect)
-        } =>
-            let n = name.map {escapeResolved(_)}.else {"i"}
-            let newAsync = self.emittingAsync && effectTypeIsAsync(effect)
-            let await = if(newAsync) {"await "} else {""}
-            await + "((() => {\n" +
-            "const size = " + self.emitArgument(at, size, async) + ";\n" + // Not correct if async and body isn't
-            "const result = [];\n" +
-            "for(let " + n + " = 0; " + n + " < size; " + n + "++) {\n" +
-            "result.push(" + self.emitTerm(body, newAsync) + ");\n" +
-            "}\n" +
-            "return result;\n" +
-            "})())"
+            code
         | ECall(at, StaticCall(name, _, True), effect, typeArguments, arguments, dictionaries) =>
             let await = async && effectTypeIsAsync(effect)
             let dictionaryStrings = dictionaries.map {self.emitDictionary(_)}
@@ -485,6 +416,13 @@ extend self: JsEmitter {
         | _ =>
             "(function() {\n" + self.emitStatements(term, True, async) + "\n})()"
     }}
+    
+    emitField(term: Term, async: Bool, dot: String = "."): String {
+        term.{
+            | EString(_, q) {safeBare(q) | Some(s)} => dot + s
+            | _ => "[" + self.emitTerm(term, async) + "]"
+        }
+    }
 
     emitDictionary(d: Dictionary): String {
         let m = if(d.moduleName != "") {
@@ -522,46 +460,6 @@ extend self: JsEmitter {
             | EAssignField(at, operator, record, field, value) =>
                 self.emitTerm(record, async) + "." + escapeKeyword(field) + " " + operator + "= " +
                 self.emitTerm(value, async)
-            | ECall(at, StaticCall("ff:core/Core.while", _, _), _, _, [condition, body], _) =>
-                "while(" + self.emitTerm(invokeImmediately(condition.value), async) + ") {\n" +
-                self.emitStatements(invokeImmediately(body.value), False, async) + "\n}"
-            | ECall(at, StaticCall("ff:core/Core.doWhile", _, _), _, _, [Argument(_, _, doWhileBody)], _) {
-                invokeImmediately(doWhileBody) | ESequential(_, body, condition)
-            } =>
-                "while(true) {\n" +
-                self.emitStatements(body, False, async) +
-                "\nif(!" + self.emitTerm(condition, async) + ") break" +
-                "\n}"
-            | ECall(at, StaticCall("ff:core/Core.doWhile", _, _), _, _, [Argument(_, _, doWhileBody)], _) {
-                invokeImmediately(doWhileBody) | body
-            } =>
-                "while(" + self.emitTerm(body, async) + ") {}"
-            | ECall(at, StaticCall("ff:core/Core.if", _, _), _, _, [condition, body], _) =>
-                "if(" + self.emitTerm(condition.value, async) + ") {\n" +
-                if(last) {
-                    "return ff_core_Option.Some(" + self.emitTerm(invokeImmediately(body.value), async) +
-                    ")\n} else return ff_core_Option.None()"
-                } else {
-                    self.emitStatements(invokeImmediately(body.value), False, async) + "\n}"
-                }
-            | ECall(at, StaticCall("ff:core/Core.throw", _, _), _, _, [argument], [dictionary]) =>
-                let d = self.emitDictionary(dictionary)
-                let a = self.emitArgument(at, argument, async)
-                "throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(" + a + ", " + d + ")})"
-            | ECall(at, StaticCall("ff:core/Try.Try_catch", _, _), _, _, _, _) {
-                self.emitTryCatchFinally(term, last, async) | Some(code)
-            } =>
-                code
-            | ECall(at, StaticCall("ff:core/Try.Try_catchAny", _, _), _, _, _, _) {
-                self.emitTryCatchFinally(term, last, async) | Some(code)
-            } =>
-                code
-            | ECall(at, StaticCall("ff:core/Try.Try_finally", _, _), _, _, _, _) {
-                self.emitTryCatchFinally(term, last, async) | Some(code)
-            } =>
-                code
-            | ECall(at, StaticCall("ff:core/UnsafeJs.throwIfCancelled", _, _), _, _, [], _) =>
-                if(async) {"ff_core_Task.Task_throwIfAborted($task)"} else {""}
             | ECall(at, StaticCall(name, True, instanceCall), effect, _, arguments, _) =>
                 if(instanceCall) {throw(CompileError(at, "Not yet implemented: Tail calls on trait methods."))}
                 self.tailCallUsed = True
@@ -572,6 +470,10 @@ extend self: JsEmitter {
                     ))
                 }.collect {_}.unzip()
                 "{\n" + pair.first.join("\n") + "\n" + pair.second.join("\n") + "\ncontinue _tailcall\n}"
+            | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
+                self.emitSpecialStatement(term, last, async, name, arguments.map {_.value}, dictionaries) | Some(code)
+            } =>
+                code
             | EPipe(at, value, _, ELambda(_, Lambda(_, _, cases))) =>
                 Patterns.convertAndCheck(self.otherModules, cases)
                 if(!last) {"do "}.else {""} +
@@ -601,6 +503,221 @@ extend self: JsEmitter {
                 }
         }
     }
+    
+    emitSpecialCall(
+        term: Term
+        async: Bool
+        name: String
+        arguments: List[Term]
+        dictionaries: List[Dictionary]
+    ): Option[String] {
+        name.{
+            | operator {!operator.grabFirst().isAsciiLetter()} {arguments | [value]} =>
+                Some("(" + operator + self.emitTerm(value, async) + ")")
+            | operator {!operator.grabFirst().isAsciiLetter()} {arguments | [left, right]}  =>
+                Some("(" + self.emitTerm(left, async) + " " + operator + " " + self.emitTerm(right, async) + ")")
+            | "ff:core/List.List_grab" {arguments | [EVariable(_, x1), EVariable(_, x2)]} =>
+                Some(
+                    "(" + escapeResolved(x1) + "[" + escapeResolved(x2) + "] ?? " + 
+                    "ff_core_List.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
+                )
+            | "ff:core/Array.Array_grab" {arguments | [EVariable(_, x1), EVariable(_, x2)]} =>
+                Some(
+                    "(" + escapeResolved(x1) + ".array[" + escapeResolved(x2) + "] ?? " + 
+                    "ff_core_Array.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
+                )
+            | "ff:core/Equal.equals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
+            } =>
+                Some("(" + self.emitTerm(left, async) + " === " + self.emitTerm(right, async) + ")")
+            | "ff:core/Equal.notEquals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
+            } =>
+                Some("(" + self.emitTerm(left, async) + " !== " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.before" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " < " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.notBefore" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " >= " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.after" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " > " + self.emitTerm(right, async) + ")")
+            | "ff:core/Ordering.notAfter" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+                primitiveTypes.contains(typeName)
+            } =>
+                Some("(" + self.emitTerm(left, async) + " <= " + self.emitTerm(right, async) + ")")
+            | "ff:core/List.fillBy" {term | ECall call} {arguments | [size, ELambda(at,
+                Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)@c])@l
+            )]} {
+                !effectTypeIsAsync(call.effect)
+            } =>
+                let n = name.map {escapeResolved(_)}.else {"i"}
+                let newAsync = self.emittingAsync && effectTypeIsAsync(call.effect)
+                let await = if(newAsync) {"await "} else {""}
+                Some(
+                    await + "((() => {\n" +
+                    "const size = " + self.emitTerm(size, async) + ";\n" + // Not correct if async and body isn't
+                    "const result = [];\n" +
+                    "for(let " + n + " = 0; " + n + " < size; " + n + "++) {\n" +
+                    "result.push(" + self.emitTerm(body, newAsync) + ");\n" +
+                    "}\n" +
+                    "return result;\n" +
+                    "})())"
+                )
+            | "ff:core/UnsafeJs.import" {arguments | [EString(_, url)]} =>
+                Some(self.jsImporter.add(url.replace("\"", "")))
+            | "ff:core/UnsafeJs.await" {arguments | [body]} =>
+                if(async) {
+                    Some("(await " + self.emitTerm(body, async) + "($task))")
+                } else {
+                    Some(self.emitTerm(invokeImmediately(body), async))
+                }
+            | "ff:core/UnsafeJs.cancelled" =>
+                Some(if(async) {"$task.controller.signal.aborted"} else {"false"})
+            | "ff:core/UnsafeJs.throwIfCancelled" =>
+                Some(if(async) {"((() => ff_core_Task.Task_throwIfAborted($task))())"} else {""})
+            | "ff:core/UnsafeJs.inAsync" =>
+                Some(if(self.emittingAsync) {"true"} else {"false"})
+            | "ff:core/UnsafeJs.inBrowser" =>
+                Some(if(self.emitTarget == EmitBrowser) {"true"} else {"false"})
+            | "ff:core/UnsafeJs.inNode" =>
+                Some(if(self.emitTarget == EmitNode) {"true"} else {"false"})
+            | "ff:core/UnsafeJs.inBuild" =>
+                Some(if(self.emitTarget == EmitBuild) {"true"} else {"false"})
+            | "ff:core/UnsafeJs.value" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/UnsafeJs.fromValue" {arguments | [e]} =>
+                Some(self.emitTerm(e, async))
+            | "ff:core/JsValue.JsValue_get" {arguments | [e1, e2]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async))
+            | name {name.removeFirst("ff:core/JsValue.JsValue_call") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, e2, ...es]
+            } =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + "(" + argumentCode + ")")
+            | name {name.removeFirst("ff:core/JsValue.JsValue_callValue") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, ...es]
+            } =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some(self.emitTerm(e1, async) + "(" + argumentCode + ")")
+            | name {name.removeFirst("ff:core/JsValue.JsValue_new") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, ...es]
+            } =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some("(new " + self.emitTerm(e1, async) + "(" + argumentCode + ")" + ")")
+            | "ff:core/JsValue.JsValue_with" =>
+                function go(e: Term, fields: List[Pair[Term, Term]]): String {
+                    e.{
+                        | ECall(_, StaticCall("ff:core/JsValue.JsValue_with", _, _), _, _, [a1, a2, a3], _) =>
+                            go(a1.value, [Pair(a2.value, a3.value), ...fields])
+                        | ECall(_, StaticCall(name, _, _), _, _, [a], _) {
+                            name == "ff:core/JsSystem.JsSystem_object" || name == "ff:core/JsSystem.JsSystem_new0"
+                        } {
+                            noSideEffects(a.value)
+                        } =>
+                            "{" + fields.map {p =>
+                                self.emitField(p.first, async, dot = "") + ": " + self.emitTerm(p.second, async)
+                            }.join(", ") + "}"
+                        | _ =>
+                            "{..." + self.emitTerm(e, async) + ", " + fields.map {p =>
+                                self.emitField(p.first, async, dot = "") + ": " + self.emitTerm(p.second, async)
+                            }.join(", ") + "}"
+                    }
+                }
+                Some(go(term, []))
+            | name {name.removeFirst("ff:core/JsSystem.JsSystem_call") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, EString(_, q)@e2, ...es]
+            } {noSideEffects(e1)} =>
+                let argumentCode = es.map {self.emitTerm(_, async)}.join(", ")
+                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e2, async) + "]"} + "(" + argumentCode + ")")
+            | name {name.removeFirst("ff:core/JsSystem.JsSystem_function") | Some(n)} {n.all {_.isAsciiDigit()}} {
+                arguments | [e1, e2]
+            } {noSideEffects(e1)} {term | ECall call} {!effectTypeIsAsync(call.effect)} =>
+                Some(self.emitTerm(e2, async))
+            | "ff:core/JsSystem.JsSystem_get" {arguments | [e1, EString(_, q)@e2]} {noSideEffects(e1)} =>
+                Some(safeBare(q).else {"globalThis[" + self.emitTerm(e2, async) + "]"})
+            | "ff:core/JsSystem.JsSystem_object" {arguments | [e]} {noSideEffects(e)} =>
+                Some("{}")
+            | "ff:core/JsSystem.JsSystem_new0" {arguments | [e]} {noSideEffects(e)} =>
+                Some("{}")
+            | "ff:core/JsSystem.JsSystem_null" {arguments | [e]} {noSideEffects(e)} =>
+                Some("null")
+            | "ff:core/JsSystem.JsSystem_undefined" {arguments | [e]} {noSideEffects(e)} =>
+                Some("(void 0)")
+            | _ =>
+                None
+        }
+    }
+    
+    emitSpecialStatement(
+        term: Term 
+        last: Bool 
+        async: Bool 
+        name: String
+        arguments: List[Term]
+        dictionaries: List[Dictionary]
+    ): Option[String] {
+        name.{
+            | "ff:core/Core.while" {arguments | [condition, body]} =>
+                Some(
+                    "while(" + self.emitComma(invokeImmediately(condition), async) + ") {\n" +
+                    self.emitStatements(invokeImmediately(body), False, async) + "\n}"
+                )
+            | "ff:core/Core.doWhile" {arguments | [doWhileBody]} {
+                invokeImmediately(doWhileBody) | ESequential(_, body, condition)
+            } =>
+                Some(
+                    "while(true) {\n" +
+                    self.emitStatements(body, False, async) +
+                    "\nif(!" + self.emitComma(condition, async) + ") break" +
+                    "\n}"
+                )
+            | "ff:core/Core.doWhile" {arguments | [doWhileBody]} {
+                invokeImmediately(doWhileBody) | body
+            } =>
+                Some("while(" + self.emitComma(body, async) + ") {}")
+            | "ff:core/Core.if" {arguments | [condition, body]} =>
+                Some(
+                    "if(" + self.emitComma(condition, async) + ") {\n" +
+                    if(last) {
+                        "return ff_core_Option.Some(" + self.emitTerm(invokeImmediately(body), async) +
+                        ")\n} else return ff_core_Option.None()"
+                    } else {
+                        self.emitStatements(invokeImmediately(body), False, async) + "\n}"
+                    }
+                )
+            | "ff:core/Core.throw" {term | ECall c} {c.arguments | [argument]} {dictionaries | [dictionary]} =>
+                let d = self.emitDictionary(dictionary)
+                let a = self.emitArgument(term.at, argument, async)
+                Some("throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(" + a + ", " + d + ")})")
+            | "ff:core/Try.Try_catch" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
+                Some(code)
+            | "ff:core/Try.Try_catchAny" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
+                Some(code)
+            | "ff:core/Try.Try_finally" {self.emitTryCatchFinally(term, last, async) | Some(code)} =>
+                Some(code)
+            | "ff:core/UnsafeJs.throwIfCancelled" =>
+                Some(if(async) {"ff_core_Task.Task_throwIfAborted($task)"} else {""})
+            | "ff:core/JsValue.JsValue_set" {arguments | [e1, e2, e3]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " = " + self.emitTerm(e3, async))
+            | "ff:core/JsValue.JsValue_increment" {arguments | [e1, e2, e3]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " += " + self.emitTerm(e3, async))
+            | "ff:core/JsValue.JsValue_decrement" {arguments | [e1, e2, e3]} =>
+                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " -= " + self.emitTerm(e3, async))
+            | "ff:core/JsSystem.JsSystem_set" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
+                Some(s + " = " + self.emitTerm(e3, async))
+            | "ff:core/JsSystem.JsSystem_increment" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
+                Some(s + " += " + self.emitTerm(e3, async))
+            | "ff:core/JsSystem.JsSystem_decrement" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
+                Some(s + " -= " + self.emitTerm(e3, async))
+            | _ =>
+                None
+        }
+    }
 
     emitTryCatchFinally(term: Term, last: Bool, async: Bool): Option[String] {
         function emitCatch(catchEffect: Type, cases: List[MatchCase]): String {
@@ -866,6 +983,22 @@ extend self: JsEmitter {
                 self.emitTerm(value, async)
         }
     }
+    
+    emitComma(term: Term, async: Bool): String {
+        term.{
+            | ESequential(_, ESequential(_, before1, before2), after) {
+                safeCommable(before1) && safeCommable(before2)
+            } =>
+                "(" + self.emitStatements(before1, False, async) + ", " + 
+                self.emitStatements(before2, False, async) + ", " + 
+                self.emitTerm(after, async) + ")"
+            | ESequential(_, before, after) {safeCommable(before)} =>
+                "(" + self.emitStatements(before, False, async) + ", " + 
+                self.emitTerm(after, async) + ")"
+            | _ =>
+                self.emitTerm(term, async)
+        }
+    }
 
 }
 
@@ -899,6 +1032,21 @@ invokeImmediately(function: Term): Term {
         ECall(function.at, DynamicCall(function, False), effect, [], [], [])
 }
 
+safeCommable(term: Term): Bool {
+    term.{
+        | EField _ => True
+        | EVariable _ => True
+        | EAssign _ => True
+        | EAssignField _ => True
+        | ECall _ => True
+        | EString(_, _) => True
+        | EInt(_, _) => True
+        | EChar(_, _) => True
+        | EFloat(_, _) => True
+        | _ => False
+    }
+}
+
 extractTypeName(type: Type): String {
     | TVariable(at, index) =>
         fail(at, "Unexpected type variable: $" + index)
@@ -946,6 +1094,29 @@ effectTypeIsAsync(effect: Type): Bool {
     | _ => False
 }
 
+safeBare(quotedString: String): Option[String] {
+    // TODO: And not a reserved word in JS
+    quotedString.removeFirst("\"").flatMap {_.removeLast("\"")}.filter {s => 
+        s.first().any {_.isAsciiLetter()} && s.all {_.isAsciiLetterOrDigit()}
+    }
+}
+
+noSideEffects(term: Term): Bool {
+    term.{
+        | EField(_, _, e, _) => noSideEffects(e)
+        | EVariable(_, _) => True
+        | ECall(_, StaticCall("ff:core/BrowserSystem.BrowserSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
+        | ECall(_, StaticCall("ff:core/BuildSystem.BuildSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
+        | ECall(_, StaticCall("ff:core/NodeSystem.NodeSystem_js", _, _), _, _, [a], _) => noSideEffects(a.value)
+        | ECall(_, StaticCall("ff:core/UnsafeJs.jsSystem", _, _), _, _, _, _) => True
+        | EString(_, _) => True
+        | EInt(_, _) => True
+        | EChar(_, _) => True
+        | EFloat(_, _) => True
+        | _ => False
+    }
+}
+
 primitiveTypes = [
     "ff:core/Bool.Bool"
     "ff:core/Char.Char"

package/compiler/Parser.ff

@@ -1135,8 +1135,8 @@ extend self: Parser {
     }
 
     parseUnary(): Term {
-        if(self.current().is(LOperator)) {
-            let token = self.skip(LOperator)
+        if(self.current().is2(LUnary, LOperator)) {
+            let token = if(self.current().is(LUnary)) {self.skip(LUnary)} else {self.skip(LOperator)}
             let term = self.parseUnary()
             let effect = self.freshUnificationVariable(token.at())
             let target = DynamicCall(EVariable(token.at(), token.raw()), False)
@@ -1152,7 +1152,7 @@ extend self: Parser {
             True
         } else {False}
         mutable result = self.parseAtom()
-        while {self.current().is4(LBracketLeft, LColon, LDot, LArrowThin) || self.current().rawIs2("!", "?")} {
+        while {self.current().is5(LBracketLeft, LColon, LDot, LArrowThin, LUnary)} {
             if(self.current().is(LDot)) {
                 self.skip(LDot)
                 if(self.current().rawIs("{")) {
@@ -1167,8 +1167,8 @@ extend self: Parser {
                 }
             } elseIf {self.current().is(LArrowThin)} {
                 result = self.parseDynamicMember(result)
-            } elseIf {self.current().rawIs2("!", "?")} {
-                let token = self.skip(LOperator)
+            } elseIf {self.current().is(LUnary)} {
+                let token = self.skip(LUnary)
                 let method = if(token.rawIs("!")) {"ff:core/UnsafeJs.value"} else {"ff:core/UnsafeJs.fromValue"}
                 let target = DynamicCall(EVariable(token.at(), method), False)
                 let effect = self.freshUnificationVariable(token.at())

package/compiler/Token.ff

@@ -42,6 +42,10 @@ extend token: Token {
         token.kind == kind1 || token.kind == kind2 || token.kind == kind3 || token.kind == kind4
     }
 
+    is5(kind1: TokenKind, kind2: TokenKind, kind3: TokenKind, kind4: TokenKind, kind5: TokenKind): Bool {
+        token.kind == kind1 || token.kind == kind2 || token.kind == kind3 || token.kind == kind4 || token.kind == kind5
+    }
+
     rawIs(value: String): Bool {
         token.stopOffset - token.startOffset == value.size() &&
         token.code.startsWith(value, token.startOffset)
@@ -75,6 +79,7 @@ data TokenKind {
     LBracketLeft
     LBracketRight
     LOperator
+    LUnary
     LComma
     LSeparator
     LDot
@@ -105,6 +110,7 @@ extend self: TokenKind {
             | LWildcard => True
             | LBracketLeft => False
             | LBracketRight => True
+            | LUnary => True
             | LOperator => False
             | LComma => False
             | LSeparator => False
@@ -135,6 +141,7 @@ extend self: TokenKind {
             | LWildcard => True
             | LBracketLeft => True
             | LBracketRight => False
+            | LUnary => True
             | LOperator => False
             | LComma => False
             | LSeparator => False
@@ -165,6 +172,7 @@ extend self: TokenKind {
             | LWildcard => True
             | LBracketLeft => False
             | LBracketRight => False
+            | LUnary => False
             | LOperator => False
             | LComma => False
             | LSeparator => False

package/compiler/Tokenizer.ff

@@ -205,12 +205,12 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
                 emitToken(LComma, start, i)
 
             } elseIf {
-                (code.grab(i) == '!' || code.grab(i) == '?') && i + 1 < code.size() && 
-                (code.grab(i + 1) == '.' || code.grab(i + 1) == '-')
+                code.grab(i) == '?' || 
+                (code.grab(i) == '!' && (i + 1 >= code.size() || code.grab(i + 1) != '='))
             } {
                 
                 i += 1
-                emitToken(LOperator, start, i)
+                emitToken(LUnary, start, i)
                 
             } elseIf {operatorCharacters.contains(code.grab(i))} {
 

package/core/JsValue.ff

@@ -116,38 +116,37 @@ extend self: JsValue {
         target js sync "for(const value of self_) if(!body_(value)) break"
         target js async "for(const value of self_) if(!await body_(value, $task)) break"
 
-
-    call(name: String, arguments: List[JsValue]): JsValue
+    call[A0: IsJsValue](name: A0, arguments: List[JsValue]): JsValue
         target js sync "return self_[name_].apply(this_, arguments_)"
 
-    call0(name: String): JsValue
+    call0[A0: IsJsValue](name: A0): JsValue
         target js sync "return self_[name_].call(self_)"
 
-    call1[A1: IsJsValue](name: String, a1: A1): JsValue
+    call1[A0: IsJsValue, A1: IsJsValue](name: A0, a1: A1): JsValue
         target js sync "return self_[name_].call(self_, a1_)"
 
-    call2[A1: IsJsValue, A2: IsJsValue](name: String, a1: A1, a2: A2): JsValue
+    call2[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue](name: A0, a1: A1, a2: A2): JsValue
         target js sync "return self_[name_].call(self_, a1_, a2_)"
 
-    call3[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue](name: String, a1: A1, a2: A2, a3: A3): JsValue
+    call3[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue, A3: IsJsValue](name: A0, a1: A1, a2: A2, a3: A3): JsValue
         target js sync "return self_[name_].call(self_, a1_, a2_, a3_)"
 
-    call4[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue](name: String, a1: A1, a2: A2, a3: A3, a4: A4): JsValue
+    call4[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue](name: A0, a1: A1, a2: A2, a3: A3, a4: A4): JsValue
         target js sync "return self_[name_].call(self_, 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
+    call5[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue](name: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): JsValue
         target js sync "return self_[name_].call(self_, 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
+    call6[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue](name: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): JsValue
         target js sync "return self_[name_].call(self_, 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
+    call7[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue](name: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7): JsValue
         target js sync "return self_[name_].call(self_, 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
+    call8[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue](name: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): JsValue
         target js sync "return self_[name_].call(self_, 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
+    call9[A0: IsJsValue, A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue, A9: IsJsValue](name: A0, 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(self_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_)"
 
 
@@ -155,34 +154,34 @@ extend self: JsValue {
         target js sync "return self_.apply(this_, arguments_)"
 
     callValue0(): JsValue
-        target js sync "return self_.call(self_)"
+        target js sync "return self_.call(void 0)"
 
     callValue1[A1: IsJsValue](a1: A1): JsValue
-        target js sync "return self_.call(self_, a1_)"
+        target js sync "return self_.call(void 0, a1_)"
 
     callValue2[A1: IsJsValue, A2: IsJsValue](a1: A1, a2: A2): JsValue
-        target js sync "return self_.call(self_, a1_, a2_)"
+        target js sync "return self_.call(void 0, a1_, a2_)"
 
     callValue3[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue](a1: A1, a2: A2, a3: A3): JsValue
-        target js sync "return self_.call(self_, a1_, a2_, a3_)"
+        target js sync "return self_.call(void 0, a1_, a2_, a3_)"
 
     callValue4[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue](a1: A1, a2: A2, a3: A3, a4: A4): JsValue
-        target js sync "return self_.call(self_, a1_, a2_, a3_, a4_)"
+        target js sync "return self_.call(void 0, a1_, a2_, a3_, a4_)"
 
     callValue5[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue](a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): JsValue
-        target js sync "return self_.call(self_, a1_, a2_, a3_, a4_, a5_)"
+        target js sync "return self_.call(void 0, a1_, a2_, a3_, a4_, a5_)"
 
     callValue6[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue](a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): JsValue
-        target js sync "return self_.call(self_, a1_, a2_, a3_, a4_, a5_, a6_)"
+        target js sync "return self_.call(void 0, a1_, a2_, a3_, a4_, a5_, a6_)"
 
     callValue7[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue](a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7): JsValue
-        target js sync "return self_.call(self_, a1_, a2_, a3_, a4_, a5_, a6_, a7_)"
+        target js sync "return self_.call(void 0, a1_, a2_, a3_, a4_, a5_, a6_, a7_)"
 
     callValue8[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue](a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): JsValue
-        target js sync "return self_.call(self_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_)"
+        target js sync "return self_.call(void 0, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_)"
 
     callValue9[A1: IsJsValue, A2: IsJsValue, A3: IsJsValue, A4: IsJsValue, A5: IsJsValue, A6: IsJsValue, A7: IsJsValue, A8: IsJsValue, A9: IsJsValue](a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): JsValue
-        target js sync "return self_.call(self_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_)"
+        target js sync "return self_.call(void 0, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_)"
 
 
     new(this: JsValue, arguments: List[JsValue]): JsValue