firefly-compiler 0.4.10 → 0.4.12

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/HttpClient.ff

@@ -78,6 +78,9 @@ extend self: FetchResponse {
     readText(): String
         target js async "return await self_.text()"
 
+    readJson(): Json
+        target js async "return await self_.json()"
+
     readBuffer(): Buffer
         target js async "return new DataView(await self_.arrayBuffer())"
 

package/core/JsValue.ff

@@ -213,9 +213,6 @@ extend self: JsValue {
         target js sync "return new self_(a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_)"
 
 
-    toJson(space: Option[String] = None): String
-        target js sync "return JSON.stringify(self_, null, space_.value_)"
-
     grabPairs(): List[Pair[String, JsValue]]
         target js sync """
             if(!(self_ instanceof Object)) throw new Error('Expected object, got '+ typeof self_);;

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(indentation: 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(self, 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(self: Json, 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,174 @@ 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()}}
+}
+
+instance StringMap[T: JsonLike]: JsonLike {
+    toJson(value: StringMap[T]): Json {
+        Json.fields {setField =>
+            value.each {key, value => setField(key, toJson(value))}
+        }
+    }
+    fromJson(json: Json): Option[StringMap[T]] {
+        if(json.isObject()) {
+            let map = StringMap.make()
+            mutable convertible = True
+            json.eachWhile {key, value => 
+                fromJson(value).{
+                    | None => convertible = False
+                    | Some(v) => map.set(key, v)
+                }
+                convertible
+            }
+            if(convertible) {map}
+        }.flatten()
+    }
+}
+
+
+instance Json: HasAnyTag {
+    anyTag(): AnyTag[Json] {Any.internalAnyTag("ff:core/Json.Json[]")}
+}
+
+instance Json: Show {
+    show(value: Json): String {value.write(Some("    "))}
+}
+
+instance Json: Equal {
+    equals(a: Json, b: Json): Bool {
+        internalEquals(a, b)
+    }
+}
+
+instance Json: Order {
+    compare(a: Json, b: Json): Ordering {
+        Ordering.fromInt(internalCompare(a, b))
+    }
+}
+
+instance Json: Serializable {
+    serializeUsing(serialization: Serialization, value: Json): Unit {
+        Serializable.serializeUsing(serialization, value.write())
+    }
+    deserializeUsing(serialization: Serialization): Json {
+        Json.read(Serializable.deserializeUsing[String](serialization)).grab()
+    }
+}
+
+
+internalEquals(a: Json, b: Json): Bool
+    target js sync """
+        if(a_ === b_) {
+            return true;
+        } else if(Array.isArray(a_) || Array.isArray(b_)) {
+            if(!Array.isArray(a_) || !Array.isArray(b_)) return false;
+            if(a_.length !== b_.length) return false;
+            for(let i = 0; i < a_.length; i++) {
+                if(!internalEquals_(a_[i], b_[i])) return false;
+            }
+            return true;
+        } else if(typeof a_ === 'object' && typeof b_ === 'object' && a_ !== null && b_ !== null) {
+            const aKeys = Object.keys(a_);
+            const bKeys = Object.keys(b_);
+            if(aKeys.length !== bKeys.length) return false;
+            for(const key of aKeys) {
+                if(!Object.hasOwn(b_, key) || !internalEquals_(a_[key], b_[key])) return false;
+            }
+            return true;
+        } else {
+            return false;
+        }
+    """
+
+internalCompare(a: Json, b: Json): Int
+    target js sync """
+        if(a_ === b_) {
+            return 0;
+        } else if (a_ === null || b_ === null) {
+            return a_ === null ? -1 : 1;
+        } else if (typeof a_ === 'boolean' || typeof b_ === 'boolean') {
+            if(typeof b_ !== 'boolean') return -1;
+            if(typeof a_ !== 'boolean') return 1;
+            return a_ < b_ ? -1 : 1;
+        } else if (typeof a_ === 'number' || typeof b_ === 'number') {
+            if(typeof b_ !== 'number') return -1;
+            if(typeof a_ !== 'number') return 1;
+            if(isNaB(a_)) return isNaB(b_) ? 0 : -1;
+            if(isNaB(b_)) return 1;
+            return a_ < b_ ? -1 : 1;
+        } else if (typeof a_ === 'string' || typeof b_ === 'string') {
+            if(typeof b_ !== 'string') return -1;
+            if(typeof a_ !== 'string') return 1;
+            return a_.localeCompare(b_, 'en');
+        } else if(Array.isArray(a_) || Array.isArray(b_)) {
+            if(!Array.isArray(a_) || !Array.isArray(b_)) return a_ < b_ ? -1 : 1;
+            const length = Math.min(a_.length, b_.length);
+            for(let i = 0; i < length; i++) {
+                const cmp = internalCompare_(a_[i], b_[i]);
+                if(cmp !== 0) return cmp;
+            }
+            return a_.length - b_.length;
+        } else {
+            const aKeys = Object.keys(a_).sort();
+            const bKeys = Object.keys(b_).sort();
+            const keyResult = internalCompare_(aKeys, bKeys);
+            if(keyResult !== 0) return keyResult;
+            for(const key of aKeys) {
+                const result = internalCompare_(a_[key], b_[key]);
+                if(result !== 0) return result;
+            }
+            return 0;
+        }
+    """

package/lsp/CompletionHandler.ff

@@ -15,7 +15,7 @@ data CompletionInfo(
     secondarySort: Int = 5
 )
 
-handleCompletion(system: NodeSystem, lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool): JsValue {
+handleCompletion(lspHook: LspHook, toplevel: Bool, followedByOpenBracket: Bool): Json {
     let topLevelCompletions = if(!toplevel) {[]} else {toplevelCompletion(lspHook)}
     let patternCompletions = lspHook.results().collectFirst {
         | InferPatternHook h =>
@@ -156,11 +156,11 @@ handleCompletion(system: NodeSystem, lspHook: LspHook, toplevel: Bool, followedB
             } else {c}
         }
     }
-    completionsToJson(system.js(), [...fixedCompletions, ...fixedTypeCompletions, ...topLevelCompletions])
+    completionsToJson([...fixedCompletions, ...fixedTypeCompletions, ...topLevelCompletions])
 }
 
-completionsToJson(js: JsSystem, completions: List[CompletionInfo]): JsValue {
-    js.object()
+completionsToJson(completions: List[CompletionInfo]): Json {
+    Json.object()
         .with("isIncomplete", False)
         .with("items", completions.distinct().toArray().map {| CompletionInfo i =>
             let shownType = i.type.show([])
@@ -179,7 +179,7 @@ completionsToJson(js: JsSystem, completions: List[CompletionInfo]): JsValue {
                 | Pair(TConstructor(_, n1, _), Some(TConstructor(_, n2, _))) => n1 == n2
                 | _ => False
             }
-            js.object()
+            Json.object()
                 // Namespace or Property or Constructor or EnumMember or Constructor or Method/Function or Field/Variable
                 .with("kind"
                     if(shownType == "") {3} else:
@@ -192,12 +192,12 @@ completionsToJson(js: JsSystem, completions: List[CompletionInfo]): JsValue {
                 .with("sortText", sortText)
                 .with("preselect", preselect)
                 .with("label", i.label)
-                .with("labelDetails", js.object()
+                .with("labelDetails", Json.object()
                     .with("detail", i.extra + if(shownType == "") {""} else {": " + shownType})
                 )
                 .with("insertText", i.snippet)
                 .with("insertTextFormat", 2 /* Snippet */)
-                .with("documentation", js.object()
+                .with("documentation", Json.object()
                     .with("kind", "markdown")
                     .with("value", "```\n" + i.documentation + "\n```")
                 )