firefly-compiler 0.4.10 → 0.4.11

package/core/Array.ff

@@ -180,6 +180,14 @@ extend self[T]: Array[T] {
             }
             return result;
         """
+        
+    flatMap[S](body: T => Array[S]): Array[S] {
+        let results = Stack.make()
+        self.each {x =>
+            results.pushArray(body(x))
+        }
+        results.drain()
+    }
 
     sortBy[S: Order](body: T => S): Array[T] {
         self.sortWith {Ordering.compare(body(_), body(_))}

package/core/Json.ff

@@ -9,11 +9,6 @@ read(json: String): Option[Json]
         }
     """
 
-write(json: Json, space: Option[String] = None): String
-    target js sync """
-        return JSON.stringify(json_, null, space_.value_);
-    """
-
 string(json: String): Json
     target js sync """
         return json_;
@@ -53,17 +48,30 @@ object(): Json
         return {};
     """
 
+fields(body: ((String, Json) => Unit) => Unit): Json
+    target js sync """
+        const result = {};
+        body_((k, v) => {result[k] = v});
+        return result;
+    """
+    target js async """
+        const result = {};
+        await body_((k, v) => {result[k] = v}, $task);
+        return result;
+    """
+
 extend self: Json {
     
-    with(field: String, value: Json)
+    write(space: Option[String] = None): String
         target js sync """
-            if(typeof self_ !== 'object' || self_ === null || Array.isArray(self_)) {
-                throw new Error('Not an object: ' + JSON.stringify(self_));
-            }
-            return {...self_, [field_]: value_};
+            return JSON.stringify(self_, null, space_.value_);
         """
+
+    with[T: JsonLike](field: String, value: T): Json {
+        internalWith(field, toJson(value))
+    }
         
-    merge(that: Json)
+    merge(that: Json): Json
         target js sync """
             if(typeof self_ !== 'object' || self_ === null || Array.isArray(self_)) {
                 throw new Error('Not an object: ' + JSON.stringify(self_));
@@ -104,6 +112,38 @@ extend self: Json {
             if(!Array.isArray(self_)) throw new Error('Not an array: ' + JSON.stringify(self_));
             return self_;
         """
+        
+    grabMap(): Map[String, Json] {
+        mutable map = Map.empty()
+        self.each {key, value => 
+            map = map.add(key, value)
+        }
+        map
+    }
+
+    getString(): Option[String] {
+        if(self.isString()) {self.grabString()}
+    }
+
+    getInt(): Option[Int] {
+        if(self.isInt()) {self.grabInt()}
+    }
+
+    getFloat(): Option[Float] {
+        if(self.isFloat()) {self.grabFloat()}
+    }
+
+    getBool(): Option[Bool] {
+        if(self.isBool()) {self.grabBool()}
+    }
+
+    getArray(): Option[Array[Json]] {
+        if(self.isArray()) {self.grabArray()}
+    }
+
+    getMap(): Option[Map[String, Json]] {
+        if(self.isObject()) {self.grabMap()}
+    }
 
     isString(): Bool
         target js sync """
@@ -151,6 +191,11 @@ extend self: Json {
             return typeof self_ === 'array' ? self_[key] ?? null : null;
         """
 
+    hasField(key: String): Bool
+        target js sync """
+            return typeof self_ === 'object' && self_ !== null && !Array.isArray(self_) && Object.hasOwn(self_, key_);
+        """
+
     getField(key: String): Option[Json]
         target js sync """
             return typeof self_ === 'object' && self_ !== null && !Array.isArray(self_) && Object.hasOwn(self_, key_)
@@ -191,6 +236,12 @@ extend self: Json {
         self.each {field, value => stack.push(body(field, value))}
         stack.drain()
     }
+
+    flatMap[T](body: (String, Json) => Array[T]): Array[T] {
+        let stack = Stack.make()
+        self.each {field, value => stack.pushArray(body(field, value))}
+        stack.drain()
+    }
     
     each(body: (String, Json) => Unit) {
         if(!self.isObject()) {throw(GrabException())}
@@ -204,6 +255,14 @@ extend self: Json {
 
 }
 
+internalWith(field: String, json: Json): Json
+    target js sync """
+        if(typeof self_ !== 'object' || self_ === null || Array.isArray(self_)) {
+            throw new Error('Not an object: ' + JSON.stringify(self_));
+        }
+        return {...self_, [field_]: value_};
+    """
+
 internalEach(self: Json, body: (String, Json) => Unit): Unit
     target js sync "for(const [key, value] of Object.entries(self_)) body_(key, value)"
     target js async "for(const [key, value] of Object.entries(self_)) await body_(key, value, $task)"
@@ -211,3 +270,56 @@ internalEach(self: Json, body: (String, Json) => Unit): Unit
 internalEachWhile(self: Json, body: (String, Json) => Bool): Unit
     target js sync "for(const [key, value] of Object.entries(self_)) if(!body_(key, value)) break"
     target js async "for(const [key, value] of Object.entries(self_)) if(!await body_(key, value, $task)) break"
+
+trait T: JsonLike {
+    toJson(value: T): Json
+    fromJson(json: Json): Option[T]
+}
+
+instance Json: JsonLike {
+    toJson(value: Json): Json {value}
+    fromJson(json: Json): Option[Json] {Some(json)}
+}
+
+instance String: JsonLike {
+    toJson(value: String): Json {string(value)}
+    fromJson(json: Json): Option[String] {_.getString()}
+}
+
+instance Int: JsonLike {
+    toJson(value: Int): Json {int(value)}
+    fromJson(json: Json): Option[Int] {_.getInt()}
+}
+
+instance Float: JsonLike {
+    toJson(value: Float): Json {float(value)}
+    fromJson(json: Json): Option[Float] {_.getFloat()}
+}
+
+instance Bool: JsonLike {
+    toJson(value: Bool): Json {bool(value)}
+    fromJson(json: Json): Option[Bool] {_.getBool()}
+}
+
+instance Array[T: JsonLike]: JsonLike {
+    toJson(value: Array[T]): Json {array(value.map(toJson))}
+    fromJson(json: Json): Option[Array[T]] {
+        json.getArray().flatMap {array => 
+            mutable convertible = True
+            let stack = Stack.make()
+            array.eachWhile {item =>
+                fromJson(item).{
+                    | None => convertible = False
+                    | Some(value) => stack.push(value)
+                }
+                convertible
+            }
+            if(convertible) {stack.drain()}
+        }
+    }
+}
+
+instance List[T: JsonLike]: JsonLike {
+    toJson(value: List[T]): Json {list(value.map(toJson))}
+    fromJson(json: Json): Option[List[T]] {fromJson[Array[T]](json).map {_.toList()}}
+}

package/lsp/Handler.ff

@@ -46,7 +46,7 @@ data TokenLocation(
 
 extend self: Handler {
 
-    handleNotification(system: NodeSystem, method: String, parameters: Map[String, JsValue]): Unit {
+    handleNotification(system: NodeSystem, method: String, parameters: Map[String, Json]): Unit {
         method.{
             | "initialized" =>
             | "textDocument/didChange" => 
@@ -57,7 +57,7 @@ extend self: Handler {
         }
     }
 
-    handleRequest(system: NodeSystem, method: String, parameters: Map[String, JsValue]): ResultOrError {
+    handleRequest(system: NodeSystem, method: String, parameters: Map[String, Json]): ResultOrError {
         method.{
             | "initialize" => self.handleInitialize(system, parameters)
             | "textDocument/diagnostic" => self.handleDiagnostic(system, parameters)
@@ -82,15 +82,15 @@ extend self: Handler {
                     self.handleReferences(system, targetAt, local = True)
                 }
             | "workspace/symbol" => self.printTime(system.mainTask(), "handleWorkspaceSymbol") {self.handleWorkspaceSymbol(system, parameters)}
-            | "shutdown" => Result(system.js().null().toJson())
-            | _ => self.handleUnsupported(system.js())
+            | "shutdown" => Result(Json.null().write())
+            | _ => self.handleUnsupported()
         }
     }
 
     handleTokenRequestWithCache(
         system: NodeSystem
         method: String
-        parameters: Map[String, JsValue]
+        parameters: Map[String, Json]
         handle: Location => ResultOrError
     ): ResultOrError {
         let targetAt = self.findTokenFromParameters(system, parameters)
@@ -104,44 +104,43 @@ extend self: Handler {
             }
     }
 
-    handleUnsupported(js: JsSystem): ResultOrError {
+    handleUnsupported(): ResultOrError {
         Error(1234, "Unsupported method")
     }
 
-    handleInitialize(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
-        let js = system.js()
+    handleInitialize(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         self.rootPath = Some(system.pathFromUrl(parameters.grab("rootUri").grabString()))
 
-        let anyFireflyFile = js.object()
+        let anyFireflyFile = Json.object()
             .with("filters", [
-                js.object()
-                    .with("pattern", js.object()
+                Json.object()
+                    .with("pattern", Json.object()
                         .with("glob", "**/*.ff")
                         .with("matches", "file")
                     )
-            ].toArray())
+            ])
 
-        let o = js.object()
-            .with("capabilities", js.object()
-                .with("textDocumentSync", js.object()
+        let o = Json.object()
+            .with("capabilities", Json.object()
+                .with("textDocumentSync", Json.object()
                     .with("openClose", True)
                     .with("change", 1 /* TextDocumentSyncKind.Full */)
                 )
                 .with("hoverProvider", True)
                 .with("definitionProvider", True)
                 .with("documentHighlightProvider", True)
-                .with("diagnosticProvider", js.object()
+                .with("diagnosticProvider", Json.object()
                     .with("interFileDependencies", False)
                     .with("workspaceDiagnostics", False)
                 )
                 .with("documentSymbolProvider", True)
-                .with("completionProvider", js.object()
-                    .with("triggerCharacters", js.array([".", " ", "("].map {js.value(_)}))
-                    .with("allCommitCharacters", js.array([";"].map {js.value(_)}))
+                .with("completionProvider", Json.object()
+                    .with("triggerCharacters", [".", " ", "("])
+                    .with("allCommitCharacters", [";"])
                 )
-                .with("signatureHelpProvider", js.object()
-                    .with("triggerCharacters", js.array(["("].map {js.value(_)}))
-                    .with("retriggerCharacters", js.array([","].map {js.value(_)}))
+                .with("signatureHelpProvider", Json.object()
+                    .with("triggerCharacters", ["("])
+                    .with("retriggerCharacters", [","])
                 )
                 .with("referencesProvider", True)
                 .with("workspaceSymbolProvider", True)
@@ -158,16 +157,16 @@ extend self: Handler {
                 )*/
                 .with("renameProvider", True)
             )
-            .with("serverInfo", js.object()
+            .with("serverInfo", Json.object()
                 .with("name", "Firefly Language Server")
                 .with("version", "0.0.0")
             )
-        Result(o.toJson())
+        Result(o.write())
     }
 
-    handleDiagnostic(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+    handleDiagnostic(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         let js = system.js()
-        let uri = parameters.grab("textDocument").get("uri").grabString()
+        let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
         let diagnostics = try {
@@ -175,26 +174,25 @@ extend self: Handler {
             []
         } catch {| CompileError(at, message), error =>
             let tokenLocation = self.findToken(system, at)
-            let diagnostic = js.object()
-                .with("range", self.tokenLocationToLspRange(js, tokenLocation))
-                .with("severity", 1 /* Error */)
+            let diagnostic = Json.object()
+                .with("range", self.tokenLocationToLspRange(tokenLocation))
+                .with("severity", 1)
                 .with("message", message)
             [diagnostic]
         } grab()
 
-        let o = js.object()
+        let o = Json.object()
             .with("kind", "full")
-            .with("items", diagnostics.toArray())
-        Result(o.toJson())
+            .with("items", diagnostics)
+        Result(o.write())
     }
 
-    handleDocumentSymbol(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
-        let js = system.js()
-        let uri = parameters.grab("textDocument").get("uri").grabString()
+    handleDocumentSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let symbols = self.getDocumentSymbolsWithCache(system, path)
-        let lspSymbols = symbols.map {SymbolHandler.documentSymbolToLsp(js, _)}
-        Result(js.array(lspSymbols).toJson())
+        let lspSymbols = symbols.map {SymbolHandler.documentSymbolToLsp(_)}
+        Result(Json.list(lspSymbols).write())
     }
 
     getDocumentSymbols(system: NodeSystem, path: Path): List[DocumentSymbol] {
@@ -227,8 +225,7 @@ extend self: Handler {
         }
     }
 
-    handleWorkspaceSymbol(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
-        let js = system.js()
+    handleWorkspaceSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         let query = parameters.grab("query").grabString()
         let files = self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(self.rootPath.grab())}
         let symbols = files.flatMap {file => 
@@ -241,27 +238,25 @@ extend self: Handler {
             }
         }
         let limitedSymbols = symbols.sortBy {_.name.size()}.takeFirst(100)
-        let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(js, self.rootPath.grab(), _)}
-        Result(js.array(jsSymbols).toJson())        
+        let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(self.rootPath.grab(), _)}
+        Result(Json.list(jsSymbols).write())
     }
     
-    handleDidChange(system: NodeSystem, parameters: Map[String, JsValue]): Unit {
-        let js = system.js()
-        let uri = parameters.grab("textDocument").get("uri").grabString()
+    handleDidChange(system: NodeSystem, parameters: Map[String, Json]): Unit {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         self.responseCache = Map.empty()
         self.fileSymbolsCache = self.fileSymbolsCache.remove(path.absolute())
         let contentChanges = parameters.grab("contentChanges").grabArray()
         if(contentChanges.size() != 1) {throw(LanguageServerException("Expected a single element in contentChanges"))} else:
         let contentChange = contentChanges.grab(0)
-        if(!contentChange.get("range").isNullOrUndefined()) {throw(LanguageServerException("Expected a complete contentChange"))} else:
-        let content = contentChange.get("text").grabString()
+        if(!contentChange.field("range").isNull()) {throw(LanguageServerException("Expected a complete contentChange"))} else:
+        let content = contentChange.field("text").grabString()
         self.virtualFiles = self.virtualFiles.add(path.absolute(), content)
     }
 
-    handleDidClose(system: NodeSystem, parameters: Map[String, JsValue]): Unit {
-        let js = system.js()
-        let uri = parameters.grab("textDocument").get("uri").grabString()
+    handleDidClose(system: NodeSystem, parameters: Map[String, Json]): Unit {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         self.virtualFiles = self.virtualFiles.remove(path.absolute())
     }
@@ -278,10 +273,10 @@ extend self: Handler {
         } else {
             HoverHandler.handleHover(system, self, lspHook)
         }
-        Result(o.toJson())
+        Result(o.write())
     }
 
-    handleCompletion(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+    handleCompletion(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         let location = self.findLocationFromParameters(system, parameters)
         let token = self.findToken(system, location, insertToken = True)
         let completionAt = Location(
@@ -300,7 +295,7 @@ extend self: Handler {
         Result(o.toJson())
     }
 
-    handleSignatureHelp(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+    handleSignatureHelp(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         let cursorAt = self.findLocationFromParameters(system, parameters)
         let lspHook = LspHook.make(at = Some(cursorAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         try {
@@ -314,13 +309,13 @@ extend self: Handler {
         } grab()
         let o = lspHook.results().collectFirst {
             | ParseArgumentHook h {parameters.get("context") | Some(context)} {
-                context.get("activeSignatureHelp") | help
-            } {!help.isNullOrUndefined() && help.hasOwn("signatures")} {
-                help.get("signatures").get(0) | activeSignature
-            } {!activeSignature.isNullOrUndefined()} {
-                activeSignature.get("parameters").grabArray().last() | Some(fakeParameter)
+                context.field("activeSignatureHelp") | help
+            } {!help.isNull() && help.hasField("signatures")} {
+                help.field("signatures").index(0) | activeSignature
+            } {!activeSignature.isNull()} {
+                activeSignature.field("parameters").grabArray().last() | Some(fakeParameter)
             } {
-                fakeParameter.get("label").grabString() == "/* Call " + h.callAt.show() + " */"
+                fakeParameter.field("label").grabString() == "/* Call " + h.callAt.show() + " */"
             } => 
                 Some(SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName))
             | ParseArgumentHook h => 
@@ -335,29 +330,27 @@ extend self: Handler {
             | _ => 
                 None
         }
-        Result((o.else {system.js().null()}).toJson())
+        Result((o.else {Json.null()}).write())
     }
 
     handleReferences(system: NodeSystem, targetAt: Location, local: Bool): ResultOrError {
         let tokens = self.findReferences(system, targetAt, local)
-        let js = system.js()
         let o = tokens.{
-            | None => js.null()
+            | None => Json.null()
             | Some(tokens) =>
                 let lspTokens = tokens.map {self.tokenLocationToLspLocation(system, _)}
-                js.array(lspTokens)
+                Json.list(lspTokens)
         }
-        Result(o.toJson())
+        Result(o.write())
     }
 
-    handleRename(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+    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 js = system.js()
         tokens.{
             | None => Error(-32602, "Token definition not found") // InvalidParams
-            | Some([]) => Result(js.null().toJson())
+            | Some([]) => Result(Json.null().write())
             | Some([first, ..._] @ tokens) =>
                 let oldName = first.raw
                 Log.trace("Rename '" + oldName + "' to '" + newName + "'")
@@ -368,17 +361,17 @@ extend self: Handler {
                 badTokens.each {t => Log.trace("Rename bad token: " + Show.show(t))}
 
                 let byFile = goodTokens.map {t => Pair(t.file, t)}.group()
-                let allChanges = byFile.toList().foldLeft(js.object(), {| o, Pair(file, fileTokens) =>
+                let allChanges = byFile.toList().foldLeft(Json.object(), {| o, Pair(file, fileTokens) =>
                     let uri = system.path(file).url()
                     let fileChanges = fileTokens.map {tokenLocation =>
-                        js.object()
-                            .with("range", self.tokenLocationToLspRange(js, tokenLocation))
+                        Json.object()
+                            .with("range", self.tokenLocationToLspRange(tokenLocation))
                             .with("newText", newName)
                     }
-                    o.with(uri, js.array(fileChanges))
+                    o.with(uri, fileChanges)
                 })
-                let o = js.object().with("changes", allChanges)
-                Result(o.toJson())
+                let o = Json.object().with("changes", allChanges)
+                Result(o.write())
         }
     }
 
@@ -409,7 +402,6 @@ extend self: Handler {
             
         //Log.trace("definedAtList: " + Show.show(definedAtList))
 
-        let js = system.js()
         definedAtList.first().{
             | Some(definedAt) =>
                 //Log.trace("handleReferences definedAt: " + Show.show(definedAt))
@@ -449,8 +441,8 @@ extend self: Handler {
         }
     }
 
-    makeNotificationMessage(js: JsSystem, method: String, params: JsValue): JsValue {
-        js.object()
+    makeNotificationMessage(method: String, params: Json): Json {
+        Json.object()
             .with("jsonrpc", "2.0")
             .with("method", method)
             .with("params", params)
@@ -502,7 +494,7 @@ extend self: Handler {
         } grab()
     }
 
-    findTokenFromParameters(system: NodeSystem, parameters: Map[String, JsValue]): Location {
+    findTokenFromParameters(system: NodeSystem, parameters: Map[String, Json]): Location {
         let location = self.findLocationFromParameters(system, parameters)
         let token = self.findToken(system, location)
         Location(
@@ -512,28 +504,27 @@ extend self: Handler {
         )
     }
 
-    findLocationFromParameters(system: NodeSystem, parameters: Map[String, JsValue]): Location {
-        let uri = parameters.grab("textDocument").get("uri").grabString()
+    findLocationFromParameters(system: NodeSystem, parameters: Map[String, Json]): Location {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
-        let line = parameters.grab("position").get("line").grabInt() + 1
-        let column = parameters.grab("position").get("character").grabInt() + 1
+        let line = parameters.grab("position").field("line").grabInt() + 1
+        let column = parameters.grab("position").field("character").grabInt() + 1
         Location(path.absolute(), line, column)
     }
 
-    tokenLocationToLspLocation(system: NodeSystem, tokenLocation: TokenLocation): JsValue {
-        let js = system.js()
-        js.object()
+    tokenLocationToLspLocation(system: NodeSystem, tokenLocation: TokenLocation): Json {
+        Json.object()
             .with("uri", system.path(tokenLocation.file).url())
-            .with("range", self.tokenLocationToLspRange(js, tokenLocation))
+            .with("range", self.tokenLocationToLspRange(tokenLocation))
     }
 
-    tokenLocationToLspRange(js: JsSystem, tokenLocation: TokenLocation): JsValue {
-        js.object()
-            .with("start", js.object()
+    tokenLocationToLspRange(tokenLocation: TokenLocation): Json {
+        Json.object()
+            .with("start", Json.object()
                 .with("line", tokenLocation.startLine - 1)
                 .with("character", tokenLocation.startColumn - 1)
             )
-            .with("end", js.object()
+            .with("end", Json.object()
                 .with("line", tokenLocation.endLine - 1)
                 .with("character", tokenLocation.endColumn - 1)
             )

package/lsp/HoverHandler.ff

@@ -4,8 +4,7 @@ import Environment from ff:compiler
 import Syntax from ff:compiler
 import Handler
 
-handleGoToDefinition(system: NodeSystem, handler: Handler, lspHook: LspHook): JsValue {
-    let js = system.js()
+handleGoToDefinition(system: NodeSystem, handler: Handler, lspHook: LspHook): Json {
     let definedAt = lspHook.results().collect {
         | ResolveSymbolHook h => Some(h.symbol.definedAt)
         | ResolveTypeHook h => Some(h.symbol.definedAt)
@@ -31,11 +30,10 @@ handleGoToDefinition(system: NodeSystem, handler: Handler, lspHook: LspHook): Js
     definedAt.first().map {at =>
         let token = handler.findToken(system, at)
         handler.tokenLocationToLspLocation(system, token)
-    }.else {js.null()}
+    }.else {Json.null()}
 }
 
-handleHover(system: NodeSystem, handler: Handler, lspHook: LspHook): JsValue {
-    let js = system.js()
+handleHover(system: NodeSystem, handler: Handler, lspHook: LspHook): Json {
     let typeAndEffect = lspHook.results().collectFirst {
         | InferLookupHook h {h.instantiated.value | Some(instantiated)} => 
             let t = h.unification.substitute(instantiated.scheme.signature.returnType)
@@ -73,10 +71,9 @@ handleHover(system: NodeSystem, handler: Handler, lspHook: LspHook): JsValue {
             | TConstructor(_, "Q$", _) => "*This call may be asynchronous.*"
             | _ => ""
         }
-        js.object().with("contents", 
-            js.object()
-                .with("kind", "markdown")
-                .with("value", "```\n" + t.show([]) + "\n```\n" + extra)
+        Json.object().with("contents", Json.object()
+            .with("kind", "markdown")
+            .with("value", "```\n" + t.show([]) + "\n```\n" + extra)
         )
-    }.else {js.null()}
+    }.else {Json.null()}
 }