firefly-compiler 0.4.31 → 0.4.33

package/core/NodeSystem.ff

@@ -1,5 +1,8 @@
 capability NodeSystem {}
 
+class ProcessResult(exitCode: Int, standardOut: Buffer, standardError: Buffer)
+data ProcessException(problem: String)
+
 extend self: NodeSystem {
 
     arguments(): List[String]
@@ -82,6 +85,84 @@ extend self: NodeSystem {
     writeErrorLine(text: String): Unit {
         self.writeErrorText(text + "\n")
     }
+    
+    environment(): Map[String, String]
+        target node async """
+            const result = [];
+            for(const key in process.env) {
+                result.push(ff_core_Pair.Pair(key, process.env[key]));
+            }
+            return ff_core_List.List_toMap(result, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
+        """
+    
+    execute(
+        command: String
+        arguments: List[String]
+        standardIn: Buffer = Buffer.new(0)
+        workingDirectory: Option[Path] = None
+        environment: Option[Map[String, String]] = None
+        maxBuffer: Int = 16777216
+        killSignal: Int = 9
+    ): ProcessResult
+        target node async """
+            import * as childProcess from 'node:child_process';
+            const environment = environment_.value_ !== void 0 ? {} : process.env;
+            if(environment_.value_ !== void 0) {
+                ff_core_Map.Map_each(
+                    environment_.value_, 
+                    (k, v) => environment[k] = v, 
+                    ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String
+                );
+            }
+            const newProcess = childProcess.spawn(command_, arguments_, {
+                cwd: workingDirectory_.value_,
+                windowsHide: true,
+                signal: $task.controller.signal,
+                killSignal: killSignal_,
+                env: environment,
+            });
+            
+            let size = 0;
+            const out = [];
+            const err = [];
+            
+            newProcess.stdout.on('data', (data) => {
+                if(size > maxBuffer_) return;
+                size += data.byteLength;
+                if(size > maxBuffer_) newProcess.kill(killSignal_);
+                else out.push(data);
+            });
+
+            newProcess.stderr.on('data', (data) => {
+                if(size > maxBuffer_) return;
+                size += data.byteLength;
+                if(size > maxBuffer_) newProcess.kill(killSignal_);
+                else err.push(data);
+            });
+
+            return await new Promise((resolve, reject) => {
+                if(standardIn_.byteLength !== 0) {
+                    newProcess.stdin.write(standardIn_);
+                }
+                newProcess.stdin.end();
+                newProcess.on('error', error => {
+                    if(size > maxBuffer_) {
+                        reject(internalProcessError_("maxBuffer exceeded"));
+                    } else {
+                        reject(internalProcessError_(error.message));
+                    }
+                });
+                newProcess.on('close', code => {
+                    const o = Buffer.concat(out);
+                    const e = Buffer.concat(err);
+                    resolve(ProcessResult(
+                        size > maxBuffer_ ? -1 : code,
+                        new DataView(o.buffer, o.byteOffset, o.byteLength),
+                        new DataView(e.buffer, e.byteOffset, e.byteLength),
+                    ));
+                }); 
+            });
+        """
 
 }
 
@@ -95,3 +176,11 @@ internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): List[Path]
         let files = await fsPromises.readdir(path_)
         return files.map(file => path.join(path_, file))
     """
+
+internalProcessError(problem: String): Error {
+    try {
+        throw(ProcessException(problem))
+    } catchAny {error =>
+        error
+    } grab()
+}

package/core/Option.ff

@@ -4,7 +4,7 @@ data Option[T] {
 }
 
 extend self[T]: Option[T] {
-
+    
     else(body: () => T): T {
         self.{
             | None => body()
@@ -30,6 +30,13 @@ extend self[T]: Option[T] {
         }
     }
 
+    or[R](noneBody: () => R, someBody: T => R): R {
+        self.{
+            | None => noneBody()
+            | Some(value) => someBody(value)
+        }
+    }
+    
     isEmpty(): Bool {
         self.{
             | None => True
@@ -50,7 +57,7 @@ extend self[T]: Option[T] {
 
     toStream(cycle: Bool = False): Stream[T] {
         mutable next = self
-        Stream.make {
+        Stream.new {
             let result = next
             if(!cycle) {next = None}
             result
@@ -63,7 +70,7 @@ extend self[T]: Option[T] {
             | _ => None
         }
     }
-
+    
     map[R](body: T => R): Option[R] {
         self.{
             | None => None

package/core/Random.ff

@@ -8,7 +8,7 @@ seedInt(seed: Int): Random {
 }
 
 seedFloat(seed: Float): Random {
-    let buffer = Buffer.make(8)
+    let buffer = Buffer.new(8)
     buffer.setFloat64(0, seed)
     seedBuffer(buffer)
 }

package/core/RbMap.ff

@@ -161,7 +161,7 @@ extend self[K: Order, V]: RB[K, V] {
                     tailcall next()
             }
         }
-        Stream.make(next)
+        Stream.new(next)
     }
 
     each(body: (K, V) => Unit): Unit {

package/core/Serializable.ff

@@ -1,7 +1,7 @@
 data DeserializationChecksumException()
 
 serialize[T: Serializable](value: T, initialBufferSize: Int = 1024): Buffer {
-    let serialization = Serialization(Buffer.make(initialBufferSize), 0, 0)
+    let serialization = Serialization(Buffer.new(initialBufferSize), 0, 0)
     serializeUsing(serialization, value)
     serialization.autoResize(4)
     serialization.buffer.setInt32(serialization.offset, serialization.checksum)
@@ -34,7 +34,7 @@ extend self: Serialization {
     autoResize(minSpareCapacity: Int) {
         if(self.offset + minSpareCapacity > self.buffer.size()) {
             let minSize = self.buffer.size() + minSpareCapacity
-            let newBuffer = Buffer.make((self.buffer.size() * 2).max(minSize))
+            let newBuffer = Buffer.new((self.buffer.size() * 2).max(minSize))
             newBuffer.setAll(0, self.buffer)
             self.buffer = newBuffer
         }

package/core/Set.ff

@@ -1,7 +1,7 @@
 newtype Set[T](map: Map[T, Unit])
 
-empty[T](): Set[T] {
-    Set(Map.empty())
+new[T](): Set[T] {
+    Set(Map.new())
 }
 
 extend self[T: Order]: Set[T] {

package/core/Stream.ff

@@ -3,7 +3,7 @@ capability Stream[T](
     close: () => Unit
 )
 
-make[T](next: () => Option[T], close: () => Unit = {}): Stream[T] {
+new[T](next: () => Option[T], close: () => Unit = {}): Stream[T] {
     Stream(next, close)
 }
 
@@ -338,7 +338,7 @@ extend self[T]: Stream[T] {
     }
 
     toArray(): Array[T] {
-        let array = Array.make()
+        let array = Array.new()
         self.each {array.push(_)}
         array
     }
@@ -370,7 +370,7 @@ extend self[K: Order, V]: Stream[Pair[K, V]] {
 extend self: Stream[Buffer] {
 
     toBuffer(): Buffer {
-        let builder = Array.make()
+        let builder = Array.new()
         self.each {builder.push(_)}
         Buffer.fromBufferArray(builder.drain())
     }
@@ -381,7 +381,7 @@ extend self: Stream[Buffer] {
 
     readBytes(bytes: Int): Pair[List[Buffer], Stream[Buffer]] {
         if(bytes <= 0) {Pair([], self)} else:
-        let buffers = Array.make()
+        let buffers = Array.new()
         mutable buffer = self.next().grab()
         mutable taken = 0
         mutable remainder = None

package/core/StringMap.ff

@@ -1,6 +1,6 @@
 class StringMap[V] {}
 
-make[V](): StringMap[V]
+new[V](): StringMap[V]
     target js sync "return new Map()"
 
 extend self[V]: StringMap[V] {
@@ -41,7 +41,7 @@ extend self[V]: StringMap[V] {
         target js async "for(const [k, v] of self_) if(!await body_(k, v)) break"
 
     toArray(): Array[Pair[String, V]] {
-        let array = Array.make()
+        let array = Array.new()
         self.each {k, v => array.push(Pair(k, v))}
         array
     }
@@ -59,13 +59,13 @@ extend self[V]: StringMap[V] {
     }
 
     keys(): List[String] {
-        let array = Array.make()
+        let array = Array.new()
         self.each {k, v => array.push(k)}
         array.toList()
     }
 
     values(): List[V] {
-        let array = Array.make()
+        let array = Array.new()
         self.each {k, v => array.push(v)}
         array.toList()
     }

package/experimental/random/Index.ff

@@ -0,0 +1,53 @@
+data Index[K, R]()
+
+extend self[K, R]: Index[K, R] {
+    
+    get(key: K): Option[R] {
+        panic("Oops")
+    }
+
+    getUnique(key: K): Option[R] {
+        panic("Oops")
+    }
+    
+    getOnly(): Option[R] {
+        panic("Oops")
+    }
+
+    grab(key: K): R {
+        panic("Oops")
+    }
+
+    grabUnique(key: K): R {
+        panic("Oops")
+    }
+
+    grabOnly(key: K): R {
+        panic("Oops")
+    }
+
+    getAll(key: K): List[R] {
+        panic("Oops")
+    }
+
+    range(from: K, until: K): Index[K, R] {
+        panic("Oops")
+    }
+    
+    join[R1](that: Index[K, R1]): Index[K, Pair[R, R1]] {
+        panic("Oops")
+    }
+    
+    keep(only: Set[K]): Index[K, R] {
+        panic("Oops")
+    }
+    
+    filter(body: (K, R) => Bool): Index[K, R] {
+        panic("Oops")
+    }
+    
+    withKeys[K1](body: (K, R) => K1): Index[K1, R] {
+        panic("Oops")
+    }
+    
+}

package/experimental/random/MapTest.ff

@@ -8,7 +8,7 @@ main(system: NodeSystem): Unit {
 
 testStringMap(system: NodeSystem) {
     let measurement = system.time().measure {
-        let map = StringMap.make()
+        let map = StringMap.new()
         mutable i = 0
         while {i < 1000000} {
             map.set("" + i, i)
@@ -20,7 +20,7 @@ testStringMap(system: NodeSystem) {
 
 testIntMap(system: NodeSystem) {
     let measurement = system.time().measure {
-        let map = IntMap.make()
+        let map = IntMap.new()
         mutable i = 0
         while {i < 1000000} {
             map.set(i, i)

package/experimental/random/Process.ff

@@ -0,0 +1,120 @@
+capability Process {}
+
+data ProcessException(exitCode: Int)
+
+extend self: Process {
+    
+    readStream(): Stream[Buffer] {
+        
+    }
+    
+    readErrorStream(): Stream[Buffer] {
+        
+    }
+    
+    readBothStreams(): Stream[Pair[Bool, Buffer]] {
+        
+    }
+    
+    readBuffer(): Buffer {
+        
+    }
+    
+    readErrorBuffer(): Buffer {
+        
+    }
+    
+    readBothBuffers(): Pair[Buffer, Buffer] {
+        
+    }
+    
+    readText(): String {
+        
+    }
+    
+    readErrorText(): String {
+        
+    }
+    
+    readBothTexts(): Pair[String, String] {
+        
+    }
+    
+    writeStream(stream: Stream[Buffer]) {
+        
+    }
+    
+    writeBuffer(buffer: Buffer) {
+        
+    }
+    
+    writeText(text: String) {
+        
+    }
+    
+    writeLine(text: String) {
+        
+    }
+    
+    closeStandardIn() {
+        
+    }
+    
+    running(): Bool {
+        
+    }
+    
+    exitCode(): Int {
+        
+    }
+    
+    setEnvironment(environment: Map[String, String]) {
+        
+    }
+    
+    setEnvironmentVariable(name: String, value: String) {
+        
+    }
+    
+    setWorkingDirectory(path: Path) {
+        
+    }
+    
+    setArgumentZero(commandName: String) {
+        
+    }
+    
+    setRedirection(in: Bool = False, out: Bool = False, error: Bool = False) {
+        
+    }
+    
+    setCloseAfterWrite(close: Bool) {
+        
+    }
+    
+}
+
+internalExecute[T](system: NodeSystem, command: String, arguments: List[String], body: Process => T): T {
+    throw(GrabException) // TODO
+}
+
+main(system: NodeSystem) {
+    let initialize = ""
+    let hoverRequest = ""
+    function parseInitializeResponse(stream: Stream[Buffer]) {
+        
+    }
+    function parseHoverResponse(stream: Stream[Buffer]) {
+        
+    }
+    
+    system.execute("my-lsp", []) {process =>
+        process.setCloseAfterWrite(False)
+        let stream = process.readStream()
+        process.writeText(initialize)
+        let config = parseInitializeResponse(stream)
+        process.writeText(hoverRequest)
+        let hover = parseHoverResponse(stream)
+        // ...
+    }
+}

package/experimental/random/RunLength.ff

@@ -18,13 +18,13 @@ printRunLength(outStream: Stream[Buffer]) {
 }
 
 toRunLength(stream: Stream[Buffer], bufferSize: Int = 65536): Stream[Buffer] {
-    mutable outBuffer = Buffer.make(bufferSize)
+    mutable outBuffer = Buffer.new(bufferSize)
     mutable outOffset = 0
     let outBuffers = Stack.make()
     function writeByte(byte: Int): Unit {
         if(outOffset >= outBuffer.size()) {
             outBuffers.push(outBuffer)
-            outBuffer = Buffer.make(bufferSize)
+            outBuffer = Buffer.new(bufferSize)
             outOffset = 0
         }
         outBuffer.setUint8(outOffset, byte)

package/experimental/random/Symbols.ff

@@ -33,9 +33,9 @@ test(symbols: List[String], query: String) {
 }
 
 matchSymbol(symbolWords: List[String], query: String, lower: Bool): Bool {
-    let memo: IntMap[IntMap[Bool]] = IntMap.make()
+    let memo: IntMap[IntMap[Bool]] = IntMap.new()
     function go(wordIndex: Int, queryOffset: Int): Bool {
-        memo.getOrSet(wordIndex) {IntMap.make()}.getOrSet(queryOffset):
+        memo.getOrSet(wordIndex) {IntMap.new()}.getOrSet(queryOffset):
         if(queryOffset >= query.size()) {True} else:
         if(wordIndex >= symbolWords.size()) {False} else:
         prefixes(query.dropFirst(queryOffset)).any {prefix => 

package/lsp/CompletionHandler.ff

@@ -228,7 +228,7 @@ completion(
 
     let member = prefix.contains("_")
 
-    let members = Array.make()
+    let members = Array.new()
 
     let symbols = if(prefix == "") {
         environment.symbols.toList().collect {
@@ -762,7 +762,7 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
                 "        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>\")"
+                "            request.writeText(\"<script type='module' src='/js/script/script/$TM_FILENAME_BASE.mjs'></script>\")"
                 "        } elseIf {request.readPath() == \"/hello\"} {"
                 "            request.writeHeader(\"Content-Type\", \"text/plain; charset=UTF-8\")"
                 "            request.writeText(\"Hello from server!\")"
@@ -776,13 +776,10 @@ toplevelCompletion(lspHook: LspHook): List[CompletionInfo] {
                 "}"
                 ""
                 "buildMain(system: BuildSystem) {"
-                "    let browser = system.compileForBrowser(\"WebApp.ff\")"
+                "    let browser = system.compileForBrowser(\"$TM_FILENAME_BASE.ff\")"
                 "    let assets = AssetSystem.create().addAssets(\"/js\", browser.assets())"
                 "    system.setAssets(assets)"
                 "}"
-                ""
-                "// To run this, name your file WebApp.ff and type:"
-                "// firefly WebApp.ff"
             ].join("\n"), 
             member = False, 
             type = TConstructor(lspHook.at, "", []),