firefly-compiler 0.4.18 → 0.4.20

package/core/Stream.ff

@@ -337,18 +337,14 @@ extend self[T]: Stream[T] {
         result
     }
 
-    toStack(): Stack[T] {
-        let stack = Stack.make()
-        self.each {stack.push(_)}
-        stack
-    }
-
     toArray(): Array[T] {
-        self.toStack().drain()
+        let array = Array.make()
+        self.each {array.push(_)}
+        array
     }
 
     toList(): List[T] {
-        self.toStack().toList()
+        self.toArray().drain()
     }
 
 }
@@ -361,20 +357,20 @@ extend self[T]: Stream[Stream[T]] {
 
 extend self[T: Order]: Stream[T] {
     toSet(): Set[T] {
-        self.toArray().toSet()
+        self.toList().toSet()
     }
 }
 
 extend self[K: Order, V]: Stream[Pair[K, V]] {
     toMap(): Map[K, V] {
-        self.toArray().toMap()
+        self.toList().toMap()
     }
 }
 
 extend self: Stream[Buffer] {
 
     toBuffer(): Buffer {
-        let builder = Stack.make()
+        let builder = Array.make()
         self.each {builder.push(_)}
         Buffer.fromBufferArray(builder.drain())
     }
@@ -383,9 +379,9 @@ extend self: Stream[Buffer] {
         self.toBuffer().toString(encoding)
     }
 
-    readBytes(bytes: Int): Pair[Array[Buffer], Stream[Buffer]] {
-        if(bytes <= 0) {Pair([].toArray(), self)} else:
-        let buffers = Stack.make()
+    readBytes(bytes: Int): Pair[List[Buffer], Stream[Buffer]] {
+        if(bytes <= 0) {Pair([], self)} else:
+        let buffers = Array.make()
         mutable buffer = self.next().grab()
         mutable taken = 0
         mutable remainder = None

package/core/String.ff

@@ -67,7 +67,7 @@ extend self: String {
     slice(from: Int, until: Int): String
         target js sync "return self_.slice(from_, until_)"
 
-    split(char: Char): Array[String]
+    split(char: Char): List[String]
         target js sync "return self_.split(String.fromCharCode(char_))"
 
     splitFirst(char: Char): Option[Pair[String, String]]
@@ -80,9 +80,9 @@ extend self: String {
 
     lines(): List[String]
         target js sync """
-            return ff_core_Array.Array_toList(self_.split(
+            return self_.split(
                 new RegExp("[" + String.fromCharCode(13) + "]?[" + String.fromCharCode(10) + "]", "g")
-            ))
+            )
         """
 
     dropFirst(count: Int = 1): String
@@ -98,10 +98,19 @@ extend self: String {
             }
             for(let i = 0; i < self_.length; i++) {
                 const c = self_.codePointAt(i)
-                if(c < 48 || c > 57) ff_core_Option.None()
+                if(c < 48 || c > 57) return ff_core_Option.None()
             }
             return ff_core_Option.Some(parseInt(self_, 10));
         """
+        
+    getFloat(): Float
+        target js sync """
+            const result = parseFloat(self_, 10);
+            if(!isFinite(result)) {
+                return ff_core_Option.None()
+            }
+            return ff_core_Option.Some(result);
+        """        
 
     grabInt(): Int
         target js sync """
@@ -114,6 +123,15 @@ extend self: String {
             }
             return parseInt(self_, 10);
         """
+        
+    grabFloat(): Float
+        target js sync """
+            const result = parseFloat(self_, 10);
+            if(!isFinite(result)) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            return result;
+        """    
 
     first(): Option[Char]
         target js sync """
@@ -129,9 +147,9 @@ extend self: String {
                 : ff_core_Option.None()
         """
 
-    grabFirst(): Char { self.first().else {Try.internalThrowGrabException()} }
+    grabFirst(): Char {self.first().else {Try.internalThrowGrabException()}}
 
-    grabLast(): Char { self.last().else {Try.internalThrowGrabException()} }
+    grabLast(): Char {self.last().else {Try.internalThrowGrabException()}}
 
     contains(substring: String): Bool
         target js sync "return self_.includes(substring_)"

package/core/StringMap.ff

@@ -40,38 +40,34 @@ extend self[V]: StringMap[V] {
         target js sync "for(const [k, v] of self_) if(!body_(k, v)) break"
         target js async "for(const [k, v] of self_) if(!await body_(k, v)) break"
 
-    toStack(): Stack[Pair[String, V]] {
-        let stack = Stack.make()
-        self.each {k, v => stack.push(Pair(k, v))}
-        stack
-    }
-
     toArray(): Array[Pair[String, V]] {
-        self.toStack().drain()
+        let array = Array.make()
+        self.each {k, v => array.push(Pair(k, v))}
+        array
     }
 
     toList(): List[Pair[String, V]] {
-        self.toArray().toList()
+        self.toArray().drain()
     }
 
     toStream(): Stream[Pair[String, V]] {
-        self.toArray().toStream()
+        self.toList().toStream()
     }
 
     toMap(): Map[String, V] {
-        self.toArray().toMap()
+        self.toList().toMap()
     }
 
     keys(): List[String] {
-        let stack = Stack.make()
-        self.each {k, v => stack.push(k)}
-        stack.toList()
+        let array = Array.make()
+        self.each {k, v => array.push(k)}
+        array.toList()
     }
 
     values(): List[V] {
-        let stack = Stack.make()
-        self.each {k, v => stack.push(v)}
-        stack.toList()
+        let array = Array.make()
+        self.each {k, v => array.push(v)}
+        array.toList()
     }
 
     copy(): StringMap[V]
@@ -84,12 +80,12 @@ extend self[V]: StringMap[V] {
             
 }
 
-extend self[V]: StringMap[Stack[V]] {
+extend self[V]: StringMap[Array[V]] {
 
     push(key: String, value: V) {
         self.get(key).{
-            | None => self.set(key, [value].toStack())
-            | Some(stack) => stack.push(value)
+            | None => self.set(key, [value].toArray())
+            | Some(array) => array.push(value)
         }
     }
 

package/guide/Main.ff

@@ -1,4 +1,22 @@
 nodeMain(system: NodeSystem) {
-    let text = system.httpClient().fetch("https://www.example.com/").readText()
-    system.writeLine(text)
+    
+    //let lines = system.path("data.txt").readText().lines()
+    let lines = [
+        "Monday:    22.5"
+        "Tuesday:   25.7"
+        "Wednesday: 23.9"
+        "Thursday:  22.4"
+        "Friday:    20.3"
+        ""
+        "Saturday:  16.2"
+        "Sunday:    21.1        "
+    ]
+    let pairs = lines.map {_.split(':')}.collect {
+        | [day, temp] => Some(Pair(day.trim(), temp.trim().grabFloat()))
+        | _ => None
+    }
+    let remaining = pairs.map {_.second}.sort().dropFirst().dropLast()
+    let average = remaining.foldLeft(0.0) {_ + _} / remaining.size()
+    system.writeLine("Average temperature: " + average)
+    
 }

package/lsp/CompletionHandler.ff

@@ -72,7 +72,7 @@ handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool):
                     completion(h.unification, h.environment, typePrefix, qualifiedByAlias, expected)
             }
         | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} =>
-            let fieldNames = n.split('$').toList().dropFirst(1)
+            let fieldNames = n.split('$').dropFirst(1)
             let fieldCompletions = fieldNames.zip(ts).map {| Pair(name, t) =>
                 let t2 = h.unification.substitute(t)
                 CompletionInfo(name, "", name, True, t2, "(\n    ...\n    " + name + ": " + t2.show([]) + "\n    ...\n)", Some(h.expected))
@@ -162,7 +162,7 @@ handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool):
 completionsToJson(completions: List[CompletionInfo]): Json {
     Json.object()
         .with("isIncomplete", False)
-        .with("items", completions.distinct().toArray().map {| CompletionInfo i =>
+        .with("items", completions.distinct().map {| CompletionInfo i =>
             let shownType = i.type.show([])
             let isAlpha = i.label.first().any {_.isAsciiLetter()}
             let isLower = i.label.first().any {_.isAsciiLower()}
@@ -228,7 +228,7 @@ completion(
 
     let member = prefix.contains("_")
 
-    let members = Stack.make()
+    let members = Array.make()
 
     let symbols = if(prefix == "") {
         environment.symbols.toList().collect {
@@ -258,7 +258,7 @@ completion(
                 None
         }.toMap()
     } else {
-        members.pushAll(exhaustiveMatchCompletion(environment, prefix, False).toStack())
+        members.pushArray(exhaustiveMatchCompletion(environment, prefix, False).toArray())
         let shorterPrefix = prefix.dropLast()
         let recordFields = shorterPrefix.split('$').dropFirst().toSet()
         environment.symbols.each {
@@ -748,8 +748,8 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
             label = "webapp", 
             extra = " with frontend and backend", 
             snippet = [
-                "dependency ff:httpserver:0.0.0"
-                "import HttpServer from ff:httpserver"
+                "dependency ff:webserver:0.0.0"
+                "import WebServer from ff:webserver"
                 ""
                 "browserMain(system: BrowserSystem): Unit {"
                 "    let response = system.httpClient().fetch(\"http://localhost:8080/hello\")"
@@ -758,19 +758,19 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
                 "}"
                 ""
                 "nodeMain(system: NodeSystem): Unit {"
-                "    HttpServer.listen(system, \"localhost\", 8080) {request, response =>"
-                "        if(request.path() == \"/\") {"
-                "            response.setHeader(\"Content-Type\", [\"text/html; charset=UTF-8\"])"
-                "            response.writeText(\"<!doctype html>\")"
-                "            response.writeText(\"<script type='module' src='/js/script/script/WebApp.mjs'></script>\")"
-                "        } elseIf {request.path() == \"/hello\"} {"
-                "            response.setHeader(\"Content-Type\", [\"text/plain; charset=UTF-8\"])"
-                "            response.writeText(\"Hello from server!\")"
-                "        } elseIf {request.path().startsWith(\"/js/\") && !request.path().contains(\"..\")} {"
-                "            response.setHeader(\"Content-Type\", [\"text/javascript; charset=UTF-8\"])"
-                "            response.writeText(system.assets().readText(request.path()))"
+                "    WebServer.make(system, \"localhost\", 8080).listen {request =>"
+                "        if(request.readPath() == \"/\") {"
+                "            request.writeHeader(\"Content-Type\", \"text/html; charset=UTF-8\")"
+                "            request.writeText(\"<!doctype html>\")"
+                "            request.writeText(\"<script type='module' src='/js/script/script/WebApp.mjs'></script>\")"
+                "        } elseIf {request.readPath() == \"/hello\"} {"
+                "            request.writeHeader(\"Content-Type\", \"text/plain; charset=UTF-8\")"
+                "            request.writeText(\"Hello from server!\")"
+                "        } elseIf {request.readPath().startsWith(\"/js/\") && !request.readPath().contains(\"..\")} {"
+                "            request.writeHeader(\"Content-Type\", \"text/javascript; charset=UTF-8\")"
+                "            request.writeText(system.assets().readText(request.readPath()))"
                 "        } else {"
-                "            response.writeStatus(404, Some(\"Not found\"))"
+                "            request.writeStatus(\"404 Not found\")"
                 "        }"
                 "    }"
                 "}"

package/lsp/Handler.ff

@@ -17,10 +17,16 @@ capability Handler(
     mutable rootPath: Option[Path]
     mutable virtualFiles: Map[String, String]
     mutable cancelledRequests: Set[MessageId]
-    mutable responseCache: Map[Pair[String, Location], ResultOrError]
+    mutable responseCache: Map[TokenRequestCacheKey, ResultOrError]
     mutable fileSymbolsCache: Map[String, List[DocumentSymbol]]
 )
 
+data TokenRequestCacheKey(
+    method: String
+    targetAt: Location
+    includeDeclaration: Bool
+)
+
 data MessageId {
     MessageIdInt(id: Int)
     MessageIdString(id: String)
@@ -77,21 +83,21 @@ extend self: Handler {
             | "textDocument/completion" => self.handleCompletion(system, parameters)
             | "textDocument/signatureHelp" => self.handleSignatureHelp(system, parameters)
             | "textDocument/hover" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
-                    self.handleHover(system, targetAt, goToDefinition = False)
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleHover(system, key.targetAt, goToDefinition = False)
                 }
             | "textDocument/definition" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
-                    self.handleHover(system, targetAt, goToDefinition = True)
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleHover(system, key.targetAt, goToDefinition = True)
                 }
             | "textDocument/references" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
-                    self.handleReferences(system, targetAt, local = False)
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleReferences(system, key.targetAt, key.includeDeclaration, local = False)
                 }
             | "textDocument/rename" => self.handleRename(system, parameters)
             | "textDocument/documentHighlight" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
-                    self.handleReferences(system, targetAt, local = True)
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleReferences(system, key.targetAt, includeDeclaration = True, local = True)
                 }
             | "workspace/symbol" => 
                 self.printTime(system.mainTask(), "handleWorkspaceSymbol") {
@@ -106,17 +112,21 @@ extend self: Handler {
         system: NodeSystem
         method: String
         parameters: Map[String, Json]
-        handle: Location => ResultOrError
+        handle: TokenRequestCacheKey => ResultOrError
     ): ResultOrError {
         let targetAt = self.findTokenFromParameters(system, parameters)
-        let cacheKey = Pair(method, targetAt)
-            self.responseCache.get(cacheKey).{
-                | Some(hit) => hit
-                | None => 
-                    let result = handle(targetAt)
-                    self.responseCache = self.responseCache.add(cacheKey, result)
-                    result
-            }
+        let includeDeclaration = parameters.get("context").{
+            | Some(context) {context.field("includeDeclaration") | includeDeclaration} {includeDeclaration.getBool() | Some(b)} => b
+            | _ => True
+        }        
+        let cacheKey = TokenRequestCacheKey(method, targetAt, includeDeclaration)
+        self.responseCache.get(cacheKey).{
+            | Some(hit) => hit
+            | None => 
+                let result = handle(cacheKey)
+                self.responseCache = self.responseCache.add(cacheKey, result)
+                result
+        }
     }
 
     handleUnsupported(): ResultOrError {
@@ -230,7 +240,7 @@ extend self: Handler {
         let path = system.pathFromUrl(uri)
         let symbols = self.getDocumentSymbolsWithCache(system, path)
         let lspSymbols = symbols.map {SymbolHandler.documentSymbolToLsp(_)}
-        Result(Json.list(lspSymbols).write())
+        Result(Json.array(lspSymbols).write())
     }
 
     getDocumentSymbols(system: NodeSystem, path: Path): List[DocumentSymbol] {
@@ -270,14 +280,14 @@ extend self: Handler {
             let documentSymbols = self.getDocumentSymbolsWithCache(system, file)
             let workspaceSymbols = documentSymbols.flatMap {SymbolHandler.documentToWorkspaceSymbols(_, None)}
             if(query == "") {
-                workspaceSymbols.filter {_.kind == 5} // Class
+                workspaceSymbols.filter {_.kind == SType}
             } else {
                 workspaceSymbols.filter {SymbolHandler.symbolFilter(_, query)}
             }
         }
         let limitedSymbols = symbols.sortBy {_.name.size()}.takeFirst(100)
         let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(self.rootPath.grab(), _)}
-        Result(Json.list(jsSymbols).write())
+        Result(Json.array(jsSymbols).write())
     }
     
     handleDidChange(system: NodeSystem, parameters: Map[String, Json]): Unit {
@@ -322,7 +332,7 @@ extend self: Handler {
             line = token.startLine
             column = token.startColumn
         )
-        Log.show(token.followedByLeftBracket)
+        //Log.show(token.followedByLeftBracket)
         let lspHook = LspHook.make(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
         try {
             Builder.check(system, self.fireflyPath, system.path(completionAt.file), self.virtualFiles, lspHook, True)
@@ -373,13 +383,13 @@ extend self: Handler {
         Result((o.else {Json.null()}).write())
     }
 
-    handleReferences(system: NodeSystem, targetAt: Location, local: Bool): ResultOrError {
-        let tokens = self.findReferences(system, targetAt, local)
+    handleReferences(system: NodeSystem, targetAt: Location, includeDeclaration: Bool, local: Bool): ResultOrError {
+        let tokens = self.findReferences(system, targetAt, local, includeDeclaration)
         let o = tokens.{
             | None => Json.null()
             | Some(tokens) =>
                 let lspTokens = tokens.map {self.tokenLocationToLspLocation(system, _)}
-                Json.list(lspTokens)
+                Json.array(lspTokens)
         }
         Result(o.write())
     }
@@ -387,11 +397,11 @@ extend self: Handler {
     handleRename(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         let newName = parameters.grab("newName").grabString()
         let targetAt = self.findTokenFromParameters(system, parameters)
-        let tokens = self.findReferences(system, targetAt, False)
+        let tokens = self.findReferences(system, targetAt, local = False, includeDeclaration = True)
         tokens.{
             | None => Error(-32602, "Token definition not found") // InvalidParams
             | Some([]) => Result(Json.null().write())
-            | Some([first, ..._] @ tokens) =>
+            | Some([first, ...] @ tokens) =>
                 let oldName = first.raw
                 Log.trace("Rename '" + oldName + "' to '" + newName + "'")
 
@@ -415,7 +425,7 @@ extend self: Handler {
         }
     }
 
-    findReferences(system: NodeSystem, targetAt: Location, local: Bool): Option[List[TokenLocation]] {
+    findReferences(system: NodeSystem, targetAt: Location, local: Bool, includeDeclaration: Bool): Option[List[TokenLocation]] {
         let temporaryLspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         try {
             Builder.check(system, self.fireflyPath, system.path(targetAt.file), self.virtualFiles, temporaryLspHook, True)
@@ -440,8 +450,6 @@ extend self: Handler {
             | _ => None
         }.filter {at => !at.file.endsWith(">")}
             
-        //Log.trace("definedAtList: " + Show.show(definedAtList))
-
         definedAtList.first().{
             | Some(definedAt) =>
                 //Log.trace("handleReferences definedAt: " + Show.show(definedAt))
@@ -465,11 +473,14 @@ extend self: Handler {
                         h.parameters.find {_.name == n}.map {_ => a.at}
                     | InferLookupHook h => Some(h.symbol.value.usageAt)
                     | _ => None
-                }.filter {at => !at.file.endsWith(">")}
-
-                //Log.trace("referencesResult: " + Show.show(referencesResult))
+                }.filter {at => 
+                    !at.file.endsWith(">") &&
+                    (includeDeclaration || at != definedAt)
+                }
 
-                let clientLocations = referencesResult.addAll([definedAt]).distinct().filter {
+                let clientLocations = referencesResult.addAll(
+                    if(includeDeclaration) {[definedAt]} else {[]}
+                ).distinct().filter {
                     !local || _.file == targetAt.file
                 }.map {at =>
                     self.findToken(system, at)

package/lsp/HoverHandler.ff

@@ -18,7 +18,7 @@ handleGoToDefinition(system: NodeSystem, handler: Handler, lspHook: LspHook): Js
                 }
             }
         | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} => 
-            let fieldNames = n.split('$').toList().dropFirst(1)
+            let fieldNames = n.split('$').dropFirst(1)
             fieldNames.zip(ts).collectFirst {| Pair(name, t) =>
                 if(h.fieldName == name) {
                     h.unification.substitute(t).at // TODO: This points to the field type rather than the field name
@@ -55,7 +55,7 @@ handleHover(system: NodeSystem, handler: Handler, lspHook: LspHook): Json {
                 }
             }
         | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} => 
-            let fieldNames = n.split('$').toList().dropFirst(1)
+            let fieldNames = n.split('$').dropFirst(1)
             fieldNames.zip(ts).collectFirst {| Pair(name, t) =>
                 if(h.fieldName == name) {
                     let noEffect = TConstructor(t.at, "ff:core/Nothing.Nothing", [])

package/lsp/LanguageServer.ff

@@ -105,13 +105,13 @@ parseRequest(system: NodeSystem, input: Stream[Buffer]): Pair[Request, Stream[Bu
     let headers = headersPair.first
     let contentLength = headers
         .get("content-length").else {throw(BadRequestException("'content-length' header is missing"))}
-        .getInt().else {throw(BadRequestException("Value for 'content-length' is not an integer"))}
+        .trim().getInt().else {throw(BadRequestException("Value for 'content-length' is not an integer"))}
     let bodyPair = parseRequestBody(contentLength, headersPair.second)
     bodyPair.mapFirst {body => Request(headers, body)}
 }
 
 parseRequestHeaders(input: Stream[Buffer]): Pair[Map[String, String], Stream[Buffer]] {
-    let buffers = Stack.make()
+    let buffers = Array.make()
     mutable buffer = input.next().else {
         throw(BadRequestException("End of input while parsing request headers"))
     }

package/lsp/SignatureHelpHandler.ff

@@ -44,7 +44,7 @@ handleSignatureHelp(system: NodeSystem, lspHook: LspHook): Json {
 
 pickActiveParameter(help: Json, argumentIndex: Int, parameterName: Option[String]): Json {
     parameterName.flatMap {name =>
-        let parameters = help.field("signatures").index(0).field("parameters").grabArray().toList()
+        let parameters = help.field("signatures").index(0).field("parameters").grabArray()
         parameters.pairs().collectFirst {| Pair(i, p) => 
             if(name == p.field("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
                 help.with("activeParameter", i)

package/lsp/SymbolHandler.ff

@@ -3,7 +3,7 @@ import Syntax from ff:compiler
 
 data DocumentSymbol(
     name: String
-    kind: Int
+    kind: DocumentSymbolKind
     selectionStart: Location
     selectionEnd: Location
     start: Location
@@ -13,7 +13,7 @@ data DocumentSymbol(
 
 data WorkspaceSymbol(
     name: String
-    kind: Int
+    kind: DocumentSymbolKind
     containerName: Option[String]
     selectionStart: Location
     selectionEnd: Location
@@ -93,16 +93,30 @@ showPosition(at: Location): String {
 documentSymbolToLsp(symbol: DocumentSymbol): Json {
     Json.object()
         .with("name", symbol.name)
-        .with("kind", symbol.kind)
+        .with("kind", documentSymbolNumber(symbol.kind))
         .with("range", locationsToLspRange(symbol.start, symbol.end))
         .with("selectionRange", locationsToLspRange(symbol.selectionStart, symbol.selectionEnd))
-        .with("children", symbol.children.toArray().map {documentSymbolToLsp(_)})
+        .with("children", symbol.children.map {documentSymbolToLsp(_)})
+}
+
+documentSymbolNumber(kind: DocumentSymbolKind): Int {
+    | SExtend => 3 // Namespace
+    | SFunction(True) => 6
+    | SFunction(False) => 12
+    | SInstance => 19 // Object
+    | SLet(True) => 13
+    | SLet(False) => 14
+    | SParameter => 7 // Property
+    | STrait => 11 // Interface
+    | STraitFunction => 12 // Function
+    | SType => 5
+    | SVariant => 10 // Enum
 }
 
 workspaceSymbolToLsp(rootPath: Path, symbol: WorkspaceSymbol): Json {
     let o = Json.object()
         .with("name", symbol.name)
-        .with("kind", symbol.kind)
+        .with("kind", documentSymbolNumber(symbol.kind))
         .with("location", Json.object()
             .with("uri", rootPath.path(symbol.selectionStart.file).url())
             .with("range", locationsToLspRange(symbol.selectionStart, symbol.selectionEnd))

package/lux/Lux.ff

@@ -8,7 +8,7 @@ capability Lux(
     mutable cssClasses: StringMap[CssClass]
     mutable renderLock: Lock
     mutable task: Task
-    mutable renderQueue: Stack[RenderQueueItem]
+    mutable renderQueue: Array[RenderQueueItem]
     mutable element: LuxElement
     mutable depth: Int
     mutable keys: Option[StringMap[JsValue]]
@@ -294,7 +294,7 @@ extend self: Lux {
             let lux = luxCopy.Lux(
                 task = task
                 renderLock = task.lock()
-                renderQueue = Stack.make()
+                renderQueue = Array.make()
                 element = luxCopy.element.LuxElement(element = fragment)
             )
             try {
@@ -475,7 +475,7 @@ render(browserSystem: BrowserSystem, element: JsValue, body: Lux => Unit) {
         keys = None
         key = ""
         attributes = None
-        renderQueue = Stack.make()
+        renderQueue = Array.make()
     )
     lux.renderLock.do(reentrant = False) {
         body(lux)