firefly-compiler 0.4.81 → 0.4.82

package/compiler/Parser.ff

@@ -1025,11 +1025,10 @@ extend self: Parser {
         if(self.current().is(LKeyword) && (self.current().rawIs("let") || self.current().rawIs("mutable"))) {self.parseLet()} else:
         if(self.current().is(LKeyword) && self.current().rawIs("function")) {self.parseFunctions()} else:
         let term = self.parseTerm()
-        if(!self.current().is(LAssign) && !self.current().is3(LAssignPlus, LAssignMinus, LAssignLink)) {term} else:
+        if(!self.current().is(LAssign) && !self.current().is2(LAssignPlus, LAssignMinus)) {term} else:
         let token = do {
             if(self.current().is(LAssignPlus)) {self.skip(LAssignPlus)} else:
             if(self.current().is(LAssignMinus)) {self.skip(LAssignMinus)} else:
-            if(self.current().is(LAssignLink)) {self.skip(LAssignLink)} else:
             self.skip(LAssign)
         }
         let operator = token.raw().dropLast(1)
@@ -1153,7 +1152,7 @@ extend self: Parser {
             True
         } else {False}
         mutable result = self.parseAtom()
-        while {self.current().is(LBracketLeft) || self.current().is(LColon) || self.current().is(LDot)} {
+        while {self.current().is4(LBracketLeft, LColon, LDot, LArrowThin)} {
             if(self.current().is(LDot)) {
                 self.skip(LDot)
                 if(self.current().rawIs("{")) {
@@ -1166,6 +1165,8 @@ extend self: Parser {
                     let token = self.skip(LLower)
                     result = EField(token.at(), False, result, token.raw())
                 }
+            } elseIf {self.current().is(LArrowThin)} {
+                result = self.parseDynamicMember(result)
             } else {
                 let at = self.current().at()
                 let typeArguments = if(!self.current().rawIs("[")) {[]} else {self.parseTypeArguments()}
@@ -1181,6 +1182,46 @@ extend self: Parser {
         }
         result
     }
+    
+    parseDynamicMember(record: Term): Term {
+        self.skip(LArrowThin)
+        let token = self.skip(LLower)
+        let member = EString(token.at(), "\"" + token.raw() + "\"")
+        if(self.current().rawIs("(")) {
+            let arguments = self.parseFunctionArguments(record.at, False)
+            let effect = self.freshUnificationVariable(record.at)
+            let target = DynamicCall(EField(token.at(), False, record, "call" + arguments.first.size()), False)
+            ECall(record.at, target, effect, [], [
+                Argument(member.at, None, member)
+                ...arguments.first
+            ], [])
+        } elseIf {self.current().is3(LAssign, LAssignPlus, LAssignMinus)} {
+            let method = 
+                if(self.current().is(LAssign)) {
+                    self.skip(LAssign)
+                    "set"
+                } elseIf {self.current().is(LAssignPlus)} {
+                    self.skip(LAssignPlus)
+                    "increment"
+                } else {
+                    self.skip(LAssignMinus)
+                    "decrement"
+                }
+            let value = self.parseTerm()
+            let effect = self.freshUnificationVariable(record.at)
+            let target = DynamicCall(EField(token.at(), False, record, "set"), False)
+            ECall(record.at, target, effect, [], [
+                Argument(member.at, None, member)
+                Argument(value.at, None, value)
+            ], [])
+        } else {
+            let effect = self.freshUnificationVariable(record.at)
+            let target = DynamicCall(EField(token.at(), False, record, "get"), False)
+            ECall(record.at, target, effect, [], [
+                Argument(member.at, None, member)
+            ], [])
+        }
+    }
 
     parseAtom(): Term {
         if(self.current().is(LString)) {

package/compiler/Token.ff

@@ -38,6 +38,10 @@ extend token: Token {
         token.kind == kind1 || token.kind == kind2 || token.kind == kind3
     }
 
+    is4(kind1: TokenKind, kind2: TokenKind, kind3: TokenKind, kind4: TokenKind): Bool {
+        token.kind == kind1 || token.kind == kind2 || token.kind == kind3 || token.kind == kind4
+    }
+
     rawIs(value: String): Bool {
         token.stopOffset - token.startOffset == value.size() &&
         token.code.startsWith(value, token.startOffset)
@@ -78,11 +82,11 @@ data TokenKind {
     LPipe
     LColon
     LDotDotDot
+    LArrowThin
     LArrowThick
     LAssign
     LAssignPlus
     LAssignMinus
-    LAssignLink
 }
 
 extend self: TokenKind {
@@ -109,11 +113,11 @@ extend self: TokenKind {
             | LPipe => False
             | LColon => False
             | LDotDotDot => False
+            | LArrowThin => False
             | LArrowThick => False
             | LAssign => False
             | LAssignPlus => False
             | LAssignMinus => False
-            | LAssignLink => False
         }
     }
 
@@ -139,11 +143,11 @@ extend self: TokenKind {
             | LPipe => False
             | LColon => False
             | LDotDotDot => True
+            | LArrowThin => False
             | LArrowThick => False
             | LAssign => False
             | LAssignPlus => False
             | LAssignMinus => False
-            | LAssignLink => False
         }
     }
 
@@ -169,11 +173,11 @@ extend self: TokenKind {
             | LPipe => False
             | LColon => False
             | LDotDotDot => False
+            | LArrowThin => False
             | LArrowThick => False
             | LAssign => False
             | LAssignPlus => False
             | LAssignMinus => False
-            | LAssignLink => False
         }
     }
 

package/compiler/Tokenizer.ff

@@ -226,6 +226,8 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
                         LColon
                     } elseIf {i - start == 3 && code.grab(i - 3) == '.' && code.grab(i - 2) == '.' && code.grab(i - 1) == '.'} {
                         LDotDotDot
+                    } elseIf {i - start == 2 && code.grab(i - 2) == '-' && code.grab(i - 1) == '>'} {
+                        LArrowThin
                     } elseIf {i - start == 2 && code.grab(i - 2) == '=' && code.grab(i - 1) == '>'} {
                         LArrowThick
                     } elseIf {i - start == 1 && code.grab(i - 1) == '='} {
@@ -234,8 +236,6 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
                         LAssignPlus
                     } elseIf {i - start == 2 && code.grab(i - 2) == '-' && code.grab(i - 1) == '='} {
                         LAssignMinus
-                    } elseIf {i - start == 3 && code.grab(i - 3) == ':' && code.grab(i - 2) == ':' && code.grab(i - 1) == '='} {
-                        LAssignLink
                     } else {
                         LOperator
                     }

package/core/JsSystem.ff

@@ -5,6 +5,18 @@ extend self: JsSystem {
     global(): 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_"
+        
     parseJson(json: String): JsValue
         target js sync "return JSON.parse(json_)"
 

package/core/JsValue.ff

@@ -88,6 +88,12 @@ extend self: JsValue {
     set[K: IsJsValue, V: IsJsValue](key: K, value: V): Unit
         target js sync "self_[key_] = value_"
 
+    increment[K: IsJsValue, V: IsJsValue](key: K, value: V): Unit
+        target js sync "self_[key_] += value_"
+        
+    decrement[K: IsJsValue, V: IsJsValue](key: K, value: V): Unit
+        target js sync "self_[key_] -= value_"
+
     delete[K: IsJsValue](key: K): Unit
         target js sync "delete self_[key_]"
 

package/lux/Lux.ff

@@ -15,6 +15,7 @@ capability Lux(
     mutable keys: Option[StringMap[JsValue]]
     mutable key: String
     mutable attributes: Option[StringMap[String]]
+    mutable texts: Array[String]
 )
 
 capability RenderQueueItem(
@@ -71,16 +72,16 @@ extend self: DryNode {
 
 extend self: LuxElement {
     childAt(index: Int): JsValue {
-        self.element.get("childNodes").get(index)
+        self.element->childNodes.get(index)
     }
     insertBefore(newNode: JsValue, referenceNode: JsValue): JsValue {
-        self.element.call2("insertBefore", newNode, referenceNode)
+        self.element->insertBefore(newNode, referenceNode)
     }
     removeAt(index: Int): Bool {
         let node = self.childAt(index)
         let remove = !node.isNullOrUndefined()
         if(remove) {
-            self.element.call1("removeChild", node)
+            self.element->removeChild(node)
         }
         remove
     }
@@ -88,15 +89,15 @@ extend self: LuxElement {
 
 extend self: LuxDocument {
     createTextNode(value: String): JsValue {
-        self.document.call1("createTextNode", value)
+        self.document->createTextNode(value)
     }
 
     createElement(tagName: String): JsValue {
-        self.document.call1("createElement", tagName)
+        self.document->createElement(tagName)
     }
     
     createFragment(): JsValue {
-        self.document.call0("createDocumentFragment")
+        self.document->createDocumentFragment()
     }
 }
 
@@ -113,27 +114,28 @@ extend self: Lux {
     }
     
     text(value: String) {
-        self.dry.map {_.push(DryText(value))}.else:
-        let oldNode = self.element.childAt(self.element.child)
-        let oldValue = if(!oldNode.isNullOrUndefined()) {oldNode.get("data")} else {oldNode}
-        if(oldValue.isNullOrUndefined() || oldValue.grabString() != value) {
-            let node = self.document.createTextNode(value)
-            self.element.insertBefore(node, oldNode)
+        if(value.size() != 0) {
+            self.texts.push(value)
         }
-        self.element.child += 1
     }
     
     add(tagName: String, body: () => Unit = {}) {
+        patchText(self)
         self.dry.map {dry => 
             self.dry = Some([].toArray())
             let savedAttributes = self.attributes
             let savedKeys = self.keys
-            self.attributes = None
+            self.attributes = if(self.key != "") {
+                let attributes = StringMap.new()
+                attributes.set("data-lux-key", tagName.upper() + ">" + self.key)
+                attributes
+            }
             self.key = ""
             self.depth += 1
             try {
                 body()
             } finally {
+                patchText(self)
                 dry.push(DryElement(tagName, self.attributes.else {StringMap.new()}, self.dry.grab()))
                 self.depth -= 1
                 self.attributes = savedAttributes
@@ -143,23 +145,24 @@ extend self: Lux {
             }
         }.else:
         let node = patchElement(self, tagName)
-        if(!node.get("luxHandlers").isNullOrUndefined()) {
-            node.get("luxHandlers").grabArray().each {pair =>
-                node.call2("removeEventListener", pair.get("event"), pair.get("handler"))
+        if(!node->luxHandlers.isNullOrUndefined()) {
+            node->luxHandlers.grabArray().each {pair =>
+                node->removeEventListener(pair->event, pair->handler)
             }
-            node.set("luxHandlers", self.jsSystem.array([]))
+            node->luxHandlers = self.jsSystem.array([])
         }
         let savedAttributes = self.attributes
         let savedKeys = self.keys
         let savedElement = self.element
         self.attributes = None
         self.element = LuxElement(node, 0, keepChildren = False)
-        self.element.element.get("classList").set("value", "")
+        self.element.element->classList->value = ""
         self.key = ""
         self.depth += 1
         try {
             body()
         } finally {
+            patchText(self)
             if(!self.element.keepChildren) {
                 doWhile {removeCurrentChild(self)}
             }
@@ -212,7 +215,7 @@ extend self: Lux {
     
     setValue(value: String) { // TODO: Not an attribute
         self.dry.map {_ => self.set("value", value)}.else:
-        self.element.element.set("value", value)
+        self.element.element->value = value
     }
     
     css(style: Css) {
@@ -233,15 +236,15 @@ extend self: Lux {
             self.cssClasses.set(class.name(), class)
             if(self.dry.isEmpty()):
             let styleSheet = self.document.createElement("style")
-            styleSheet.set("textContent", class.show())
-            self.document.document.get("head").call1("appendChild", styleSheet)
+            styleSheet->textContent = class.show()
+            self.document.document->head->appendChild(styleSheet)
         }
         if(!self.dry.isEmpty()) {
             let classNames = self.attributes.flatMap {_.get("class")}.else {""}
             self.set("class", (classNames + " " + class.name()).trim())
         } else {
-            self.element.element.get("classList").call1("add", class.name())
-            self.set("class", self.element.element.get("className").grabString())
+            self.element.element->classList->add(class.name())
+            self.set("class", self.element.element->className.grabString())
         }
     }
     
@@ -253,11 +256,11 @@ extend self: Lux {
                 processRenderQueue(self)
             }
         }
-        self.element.element.call2("addEventListener", event, jsHandler)
-        if(self.element.element.get("luxHandlers").isNullOrUndefined()) {
-            self.element.element.set("luxHandlers", self.jsSystem.array([]))
+        self.element.element->addEventListener(event, jsHandler)
+        if(self.element.element->luxHandlers.isNullOrUndefined()) {
+            self.element.element->luxHandlers = self.jsSystem.array([])
         }
-        self.element.element.get("luxHandlers").call1("push"
+        self.element.element->luxHandlers->push(
             self.jsSystem.object().with("event", event).with("handler", jsHandler)
         )
     }
@@ -410,7 +413,7 @@ processRenderQueue(self: Lux) {
 
 removeCurrentChild(self: Lux): Bool {
     let child = self.element.childAt(self.element.child)
-    if(!child.isNullOrUndefined() && !child.get("children").isNullOrUndefined()) {
+    if(!child.isNullOrUndefined() && !child->children.isNullOrUndefined()) {
         abortTasksOnElement(self, child, False)
     }
     self.element.removeAt(self.element.child)
@@ -429,21 +432,21 @@ setStateOnElement[T /*: HasAnyTag*/](element: JsValue, depth: Int, value: T): Un
 
 
 getTaskOnElement(element: JsValue): Option[Task] {
-    let value = element.get("luxTask")
+    let value = element->luxTask
     if(value.isNullOrUndefined()) {None} else {
         unsafeJsToValue(value)
     }
 }
 
 setTaskOnElement(element: JsValue, task: Option[Task]): Unit {
-    element.set("luxTask", unsafeJsFromValue(task))
+    element->luxTask = unsafeJsFromValue(task)
 }
 
 abortTasksOnElement(lux: Lux, element: JsValue, onlyChildren: Bool): Unit {
     if(!onlyChildren) {
         getTaskOnElement(element).each {task => forceAsyncAbort(lux, task)}
     }
-    element.get("children").each {child => 
+    element->children.each {child => 
         abortTasksOnElement(lux, child, False)
     }
 }
@@ -460,19 +463,34 @@ unsafeAsyncFunction1ToJs[R](self: Lux, body: JsValue => R): JsValue
 forceAsyncAbort(self: Lux, task: Task): Unit {
     task.abort()
 }
-        
+
+patchText(self: Lux) {
+    if(!self.texts.isEmpty()):
+    let value = self.texts.drain().join()
+    self.dry.map {_.push(DryText(value))}.else:
+    let oldNode = self.element.childAt(self.element.child)
+    let oldValue = if(!oldNode.isNullOrUndefined()) {oldNode->data} else {oldNode}
+    if(oldValue.isNullOrUndefined() || oldValue.grabString() != value) {
+        let node = self.document.createTextNode(value)
+        self.element.insertBefore(node, oldNode)
+    }
+    self.element.child += 1
+}
+
 patchElement(self: Lux, tagName: String): JsValue {
     let newKey = if(self.key != "") {tagName.upper() + ">" + self.key} else {""}
     let oldNode = self.element.childAt(self.element.child)
-    let oldKey = if(!oldNode.isNullOrUndefined()) {oldNode.get("luxKey")} else {oldNode}
+    let oldKey = if(!oldNode.isNullOrUndefined() && !oldNode->getAttribute.isNullOrUndefined()) {
+        oldNode->getAttribute("data-lux-key")
+    } else {oldNode}
     let match = if(newKey != "") {
         !oldKey.isNullOrUndefined() && 
         oldKey.grabString() == newKey
     } else {
         oldKey.isNullOrUndefined() && 
         !oldNode.isNullOrUndefined() &&
-        !oldNode.get("tagName").isNullOrUndefined() && 
-        oldNode.get("tagName").grabString() == tagName.upper()
+        !oldNode->tagName.isNullOrUndefined() && 
+        oldNode->tagName.grabString() == tagName.upper()
     }
     if(match) {
         oldNode
@@ -483,8 +501,10 @@ patchElement(self: Lux, tagName: String): JsValue {
                 mutable i = self.element.child
                 mutable c = self.element.childAt(i)
                 while {!c.isNullOrUndefined()} {
-                    let k = c.get("luxKey")
-                    if(!k.isNullOrUndefined()) {map.set(k.grabString(), c)}
+                    if(!c->getAttribute.isNullOrUndefined()) {
+                        let k = c->getAttribute("data-lux-key")
+                        if(!k.isNullOrUndefined()) {map.set(k.grabString(), c)}
+                    }
                     c = self.element.childAt(i)
                     i += 1
                 }
@@ -497,7 +517,7 @@ patchElement(self: Lux, tagName: String): JsValue {
                 foundNode
             } else {
                 let createdNode = self.document.createElement(tagName)
-                createdNode.set("luxKey", newKey)
+                createdNode->setAttribute("data-lux-key", newKey)
                 createdNode
             }
         }
@@ -507,28 +527,28 @@ patchElement(self: Lux, tagName: String): JsValue {
 }
 
 patchAttributes(self: Lux) {
-    let attributes = self.element.element.get("attributes")
+    let attributes = self.element.element->attributes
     self.attributes.{
         | None => 
-            mutable i = attributes.get("length").grabInt() - 1
+            mutable i = attributes->length.grabInt() - 1
             while {i >= 0} {
                 let attribute = attributes.get(i)
-                self.element.element.call1("removeAttribute", attribute.get("name"))
+                self.element.element->removeAttribute(attribute->name)
                 i -= 1
             }
         | Some(map) => 
-            mutable i = attributes.get("length").grabInt() - 1
+            mutable i = attributes->length.grabInt() - 1
             while {i >= 0} {
                 let attribute = attributes.get(i)
-                if(!map.has(attribute.get("name").grabString())) {
-                    self.element.element.call1("removeAttribute", attribute.get("name"))
+                if(!map.has(attribute->name.grabString())) {
+                    self.element.element->removeAttribute(attribute->name)
                 }
                 i -= 1
             }
             map.each {name, value =>
-                let oldValue = self.element.element.call1("getAttribute", name)
+                let oldValue = self.element.element->getAttribute(name)
                 if(oldValue.isNullOrUndefined() || !oldValue.equals(value)) {
-                    self.element.element.call2("setAttribute", name, value)
+                    self.element.element->setAttribute(name, value)
                 }
             }
     }    
@@ -536,14 +556,14 @@ patchAttributes(self: Lux) {
 
 render(browserSystem: BrowserSystem, element: JsValue, body: Lux => Unit) {
     mutable document = element
-    while {!document.get("parentNode").isNullOrUndefined()} {
-        document = document.get("parentNode")
+    while {!document->parentNode.isNullOrUndefined()} {
+        document = document->parentNode
     }
     // [...document.querySelectorAll("[lux-class]")].map(x => x.getAttribute("lux-class")) 
     let staticCssClasses = StringMap.new()
     let dummyCssClass = CssClass([], [], [])
-    document.call1("querySelectorAll", "[lux-class]").each {e => 
-        staticCssClasses.set(e.call1("getAttribute", "lux-class").grabString(), dummyCssClass)
+    document->querySelectorAll("[lux-class]").each {e => 
+        staticCssClasses.set(e->getAttribute("lux-class").grabString(), dummyCssClass)
     }
     let lux = Lux(
         jsSystem = browserSystem.js()
@@ -557,15 +577,17 @@ render(browserSystem: BrowserSystem, element: JsValue, body: Lux => Unit) {
         keys = None
         key = ""
         attributes = None
+        texts = Array.new()
         renderQueue = Array.new()
     )
     lux.renderLock.do(reentrant = False) {
         body(lux)
+        patchText(lux)
     }
 }
 
 renderById(browserSystem: BrowserSystem, id: String, body: Lux => Unit) {
-    let element = browserSystem.js().global().get("document").call1("getElementById", id)
+    let element = browserSystem.js()->document->getElementById(id)
     render(browserSystem, element, body)
 }
 
@@ -583,9 +605,11 @@ renderToString(nodeSystem: NodeSystem, body: Lux => Unit): Pair[String, String]
         keys = None
         key = ""
         attributes = None
+        texts = Array.new()
         renderQueue = Array.new()
     )
     body(lux)
+    patchText(lux)
     let styleTags = lux.cssClasses.values().map {c => 
         "<style lux-class=\"" + c.name() + "\">" + c.show() + "</style>"
     }.join()

package/lux/TestDry.ff

@@ -5,7 +5,7 @@ nodeMain(system: NodeSystem) {
     
     
     let html = Lux.renderToString(system, render)
-    Log.trace(html)
+    Log.trace(html.first)
     
 }
 
@@ -14,6 +14,7 @@ render(lux: Lux): Unit {
         lux.set("id", "its-me")
         lux.span {
             lux.text("Hello")
+            lux.keyed("noegle"):
             lux.div {
                 lux.set("id", "it's \"a-me\"")
                 lux.span {