firefly-compiler 0.4.18 → 0.4.19

package/core/Stack.ff

@@ -1,24 +1,24 @@
-class Stack[T] {}
+class Array[T] {}
 
-make[T](): Stack[T]
+make[T](): Array[T]
     target js sync "return {array: []}"
 
-fill[T](size: Int, value: T): Array[T]
+fill[T](size: Int, value: T): List[T]
     target js sync """
         return {array: new Array(size_).fill(value_)};
     """
 
-fillBy[T](size: Int, body: Int => T): Array[T]
+fillBy[T](size: Int, body: Int => T): List[T]
     target js sync """
         return {array: Array.from({length: size_}, (_, i) => body_(i))};
     """
 
-range(size: Int): Array[Int]
+range(size: Int): List[Int]
     target js sync """
         return {array: Array.from({length: size_}, (_, i) => i)};
     """
 
-extend self[T]: Stack[T] {
+extend self[T]: Array[T] {
 
     isEmpty(): Bool
         target js sync "return self_.array.length === 0"
@@ -41,9 +41,9 @@ extend self[T]: Stack[T] {
             return self_.array[index_]
         """
 
-    grabFirst(): T { self.grab(0) }
+    grabFirst(): T {self.grab(0)}
 
-    grabLast(): T { self.grab(self.size() - 1) }
+    grabLast(): T {self.grab(self.size() - 1)}
 
     first(): Option[T]
         target js sync """
@@ -62,10 +62,10 @@ extend self[T]: Stack[T] {
     push(value: T): Unit
         target js sync "self_.array.push(value_)"
 
-    pushAll(value: Stack[T]): Unit
+    pushArray(value: Array[T]): Unit
         target js sync "self_.array.push(...value_.array)"
 
-    pushArray(value: Array[T]): Unit
+    pushList(value: List[T]): Unit
         target js sync "self_.array.push(...value_)"
 
     pop(): Option[T]
@@ -117,12 +117,12 @@ extend self[T]: Stack[T] {
             self_.array.splice(start_, deleteCount_, value_);
         """
 
-    insertAll(start: Int, value: Stack[T], deleteCount: Int = 0): Unit
+    insertArray(start: Int, value: Array[T], deleteCount: Int = 0): Unit
         target js sync """
             self_.array.splice(start_, deleteCount_, ...value_.array);
         """
 
-    insertArray(start: Int, value: Array[T], deleteCount: Int = 0): Unit
+    insertList(start: Int, value: List[T], deleteCount: Int = 0): Unit
         target js sync """
             self_.array.splice(start_, deleteCount_, ...value_);
         """
@@ -170,27 +170,14 @@ extend self[T]: Stack[T] {
         if(result) {i}
     }
 
-    drain(): Array[T]
+    drain(): List[T]
         target js sync "const result = self_.array; self_.array = []; return result"
 
-    toArray(start: Int = 0, end: Int = 9007199254740991): Array[T]
-        target js sync """return self_.array.slice(start_, end_)"""
-
     toList(start: Int = 0, end: Int = 9007199254740991): List[T]
-        target js sync """
-            if(start_ < 0) start_ = self_.array.length + start_
-            if(end_ < 0) end_ = self_.array.length + start_
-            start_ = Math.max(0, Math.min(start_, self_.array.length))
-            end_ = Math.max(0, Math.min(end_, self_.array.length))
-            let result = ff_core_List.Empty();
-            for(let i = end_ - 1; i >= start_; i--) {
-                result = ff_core_List.Link(self_.array[i], result);
-            }
-            return result;
-        """
+        target js sync """return self_.array.slice(start_, end_)"""
 
     toStream(start: Int = 0, end: Int = 9007199254740991): Stream[T] {
-        self.toArray(start, end).toStream()
+        self.toList(start, end).toStream()
     }
 
     reverse(): Unit
@@ -207,7 +194,7 @@ extend self[T]: Stack[T] {
 
 }
 
-extend self[T: Order]: Stack[T] {
+extend self[T: Order]: Array[T] {
 
     sort(): Unit {
         self.sortWith(Ordering.compare)
@@ -215,46 +202,46 @@ extend self[T: Order]: Stack[T] {
 
 }
 
-extend self: Stack[String] {
+extend self: Array[String] {
 
     join(separator: String = ""): String
         target js sync "return self_.array.join(separator_)"
 
 }
 
-instance Stack[T: Show]: Show {
-    show(value: Stack[T]): String {
-        let stack = Stack.make()
-        stack.push("[")
+instance Array[T: Show]: Show {
+    show(value: Array[T]): String {
+        let array = Array.make()
+        array.push("[")
         value.each {x =>
-            if(stack.size() > 1) {stack.push(", ")}
-            stack.push(Show.show(x))
+            if(array.size() > 1) {array.push(", ")}
+            array.push(Show.show(x))
         }
-        stack.push("].toStack()")
-        stack.join()
+        array.push("].toArray()")
+        array.join()
     }
 }
 
-sortRange[T](stack: Stack[T], compare: (T, T) => Ordering, start: Int, end: Int): Unit {
+sortRange[T](array: Array[T], compare: (T, T) => Ordering, start: Int, end: Int): Unit {
     if(end - start < 2) {} else:
 
     mutable middle = start + ((end - start) / 2)
-    sortRange(stack, compare, start, middle)
-    sortRange(stack, compare, middle, end)
+    sortRange(array, compare, start, middle)
+    sortRange(array, compare, middle, end)
 
     mutable i = start
     mutable j = middle
     while {i < middle && j < end} {
-        if(compare(stack.grab(i), stack.grab(j)) != OrderingAfter) {
+        if(compare(array.grab(i), array.grab(j)) != OrderingAfter) {
             i += 1
         } else {
-            let value = stack.grab(j)
+            let value = array.grab(j)
             mutable k = j
             while {k > i} {
-                stack.set(k, stack.grab(k - 1))
+                array.set(k, array.grab(k - 1))
                 k -= 1
             }
-            stack.set(i, value)
+            array.set(i, value)
             i += 1
             middle += 1
             j += 1

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 {

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] {
@@ -277,7 +287,7 @@ extend self: Handler {
         }
         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

@@ -96,7 +96,7 @@ documentSymbolToLsp(symbol: DocumentSymbol): Json {
         .with("kind", 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(_)})
 }
 
 workspaceSymbolToLsp(rootPath: Path, symbol: WorkspaceSymbol): Json {