firefly-compiler 0.4.4

package/postgresql/Pg.ff

@@ -0,0 +1,530 @@
+import UnsafeJs from ff:unsafejs
+
+capability PgPool(jsValue: JsValue)
+capability PgConnection(jsValue: JsValue)
+capability PgRow(jsValue: JsValue) // TODO: Should be a sync class, make deriver not touch those
+capability PgStatement(sql: String, parameters: Map[String, JsValue], connection: Option[PgConnection])
+data PgLevel {
+    PgReadCommitted
+    PgRepeatableRead
+    PgSerializable
+}
+
+makePool(
+    system: NodeSystem
+    user: String
+    host: String
+    database: String
+    password: () => String
+    port: Int = 5432
+    connectionTimeout: Duration = Duration(10.0)
+    idleTimeout: Duration = Duration(10.0)
+    maxConnections: Int = 10
+    allowExitOnIdle: Bool = True
+): PgPool {
+    UnsafeJs.throwIfCancelled()
+    let js = UnsafeJs.jsSystem()
+    let pg = UnsafeJs.import("pg").get("default")
+    PgPool(pg.get("Pool").new1(js.object()
+        .with("user", user)
+        .with("host", host)
+        .with("database", database)
+        .with("password", js.function0(password))
+        .with("port", port)
+        .with("connectionTimeoutMillis", connectionTimeout.seconds * 1000)
+        .with("idleTimeoutMillis", idleTimeout.seconds * 1000)
+        .with("max", maxConnections)
+        .with("allowExitOnIdle", allowExitOnIdle)
+    ))
+}
+
+makePoolFromConnectionString(
+    system: NodeSystem
+    connectionString: String
+    connectionTimeout: Duration = Duration(10.0)
+    idleTimeout: Duration = Duration(10.0)
+    maxConnections: Int = 10
+    allowExitOnIdle: Bool = True
+): PgPool {
+    UnsafeJs.throwIfCancelled()
+    let js = UnsafeJs.jsSystem()
+    let pg = UnsafeJs.import("pg").get("default")
+    PgPool(pg.get("Pool").new1(js.object()
+        .with("connectionString", connectionString)
+        .with("connectionTimeoutMillis", connectionTimeout.seconds * 1000)
+        .with("idleTimeoutMillis", idleTimeout.seconds * 1000)
+        .with("max", maxConnections)
+        .with("allowExitOnIdle", allowExitOnIdle)
+    ))
+}
+
+extend self: PgPool {
+
+    connect(): PgConnection {
+        UnsafeJs.throwIfCancelled()
+        PgConnection(UnsafeJs.await { self.jsValue.call0("connect") })
+    }
+
+    close(): Unit {
+        UnsafeJs.await { self.jsValue.call0("end") }
+    }
+
+    connectionCount(): Int {
+        self.jsValue.get("totalCount").grabInt()
+    }
+
+    idleCount(): Int {
+        self.jsValue.get("idleCount").grabInt()
+    }
+
+    waitingCount(): Int {
+        self.jsValue.get("waitingCount").grabInt()
+    }
+
+    transaction[T](body: PgConnection => T, level: PgLevel = PgReadCommitted): T {
+        let connection = self.connect()
+        mutable done = False
+        try {
+            connection.statement("begin").run()
+            level.{
+                | PgReadCommitted => 0 // Default level in PostgreSQL
+                | PgRepeatableRead => connection.statement("set transaction isolation level repeatable read").run()
+                | PgSerializable => connection.statement("set transaction isolation level serializable").run()
+            }
+            let result = body(connection)
+            done = True
+            connection.statement("commit").run()
+            result
+        } finally {
+            if(!done) {connection.statement("rollback").run()}
+            connection.release()
+        } grab()
+    }
+
+}
+
+extend self: PgConnection {
+
+    release(): Unit {
+        if(UnsafeJs.cancelled()) {
+            self.jsValue.call1("release", True)
+        } else {
+            self.jsValue.call0("release")
+        }
+    }
+
+    statement(sql: String): PgStatement {
+        PgStatement(sql, [].toMap(), Some(self))
+    }
+
+    batchRun(statements: List[PgStatement]): List[Int] {
+        internalBatchStatements(self, statements, None, None)
+    }
+
+    batchAll(statements: List[PgStatement], body: PgRow => Bool): List[Bool] {
+        internalBatchStatements(self, statements, Some(body), None).map {_ == 1}
+    }
+
+    batchAny(statements: List[PgStatement], body: PgRow => Bool): List[Bool] {
+        self.batchAll(statements, {!body(_)}).map {!_}
+    }
+
+    batchEach(statements: List[PgStatement], body: PgRow => Unit): Unit {
+        self.batchAll(statements, {body(_); True})
+    }
+
+    batchMap[T](statements: List[PgStatement], body: PgRow => T): List[List[T]] {
+        mutable results = []
+        mutable result = []
+        internalBatchStatements(self, statements, Some({row =>
+            result = [body(row), ...result]
+            True
+        }), Some({
+            results = [result.reverse(), ...results]
+        }))
+        results.reverse()
+    }
+
+}
+
+extend self: PgStatement {
+
+    withBool(name: String, value: Bool): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableBool(name: String, value: Option[Bool]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withInt(name: String, value: Int): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableInt(name: String, value: Option[Int]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withFloat(name: String, value: Float): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableFloat(name: String, value: Option[Float]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withString(name: String, value: String): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableString(name: String, value: Option[String]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withInstant(name: String, value: Instant): PgStatement {
+        let jsDate = UnsafeJs.jsSystem().global().get("Date")
+        function toJsDate(instant: Instant): JsValue {
+            jsDate.new1(instant.since1970.seconds * 1000.0)
+        }
+        let p = toJsDate(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableInstant(name: String, value: Option[Instant]): PgStatement {
+        let jsDate = UnsafeJs.jsSystem().global().get("Date")
+        function toJsDate(instant: Instant): JsValue {
+            jsDate.new1(instant.since1970.seconds * 1000.0)
+        }
+        let p = value.map(toJsDate).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withBuffer(name: String, value: Buffer): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableBuffer(name: String, value: Option[Buffer]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withBoolArray(name: String, value: Array[Bool]): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableBoolArray(name: String, value: Option[Array[Bool]]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withIntArray(name: String, value: Array[Int]): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableIntArray(name: String, value: Option[Array[Int]]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withFloatArray(name: String, value: Array[Float]): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableFloatArray(name: String, value: Option[Array[Float]]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withStringArray(name: String, value: Array[String]): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableStringArray(name: String, value: Option[Array[String]]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withInstantArray(name: String, value: Array[Instant]): PgStatement {
+        let jsDate = UnsafeJs.jsSystem().global().get("Date")
+        function toJsDate(instant: Instant): JsValue {
+            jsDate.new1(instant.since1970.seconds * 1000.0)
+        }
+        let p = UnsafeJs.jsSystem().value(value.map(toJsDate))
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableInstantArray(name: String, value: Option[Array[Instant]]): PgStatement {
+        let jsDate = UnsafeJs.jsSystem().global().get("Date")
+        function toJsDate(instant: Instant): JsValue {
+            jsDate.new1(instant.since1970.seconds * 1000.0)
+        }
+        let p = value.map {_.map(toJsDate)}.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withBufferArray(name: String, value: Array[Buffer]): PgStatement {
+        let p = UnsafeJs.jsSystem().value(value)
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    withNullableBufferArray(name: String, value: Option[Array[Buffer]]): PgStatement {
+        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        self.PgStatement(parameters = self.parameters.add(name, p))
+    }
+
+    run(): Int {
+        internalRunStatement(self, None)
+    }
+
+    all(body: PgRow => Bool): Bool {
+        internalRunStatement(self, Some(body)) == 1
+    }
+
+    any(body: PgRow => Bool): Bool {
+        !self.all { row =>
+            !body(row)
+        }
+    }
+
+    each(body: PgRow => Unit): Unit {
+        self.all { row =>
+            body(row)
+            True
+        }
+    }
+
+    map[T](body: PgRow => T): List[T] {
+        mutable result = []
+        self.each { row =>
+            result = [body(row), ...result]
+        }
+        result.reverse()
+    }
+
+}
+
+extend self: PgRow {
+
+    getBool(name: String, lower: Bool = True): Option[Bool] {
+        internalGet(self, name, lower) {(_.grabBool() && True) || False}
+    }
+
+    getInt(name: String, lower: Bool = True): Option[Int] {
+        internalGet(self, name, lower) {_.grabInt() * 1}
+    }
+
+    getFloat(name: String, lower: Bool = True): Option[Float] {
+        internalGet(self, name, lower) {_.grabFloat() * 1.0}
+    }
+
+    getString(name: String, lower: Bool = True): Option[String] {
+        internalGet(self, name, lower) {"" + _.grabString()}
+    }
+
+    getInstant(name: String, lower: Bool = True): Option[Instant] {
+        internalGet(self, name, lower) {Instant(Duration(_.call0("getTime").grabInt() * 0.001))}
+    }
+
+    getBuffer(name: String, lower: Bool = True): Option[Buffer] {
+        internalGet(self, name, lower) {_.grabBuffer()}
+    }
+
+    getBoolArray(name: String, lower: Bool = True): Option[Array[Bool]] {
+        internalGet(self, name, lower) {_.grabArray().map {(_.grabBool() && True) || False}}
+    }
+
+    getIntArray(name: String, lower: Bool = True): Option[Array[Int]] {
+        internalGet(self, name, lower) {_.grabArray().map {_.grabInt() * 1}}
+    }
+
+    getFloatArray(name: String, lower: Bool = True): Option[Array[Float]] {
+        internalGet(self, name, lower) {_.grabArray().map {_.grabFloat() * 1.0}}
+    }
+
+    getStringArray(name: String, lower: Bool = True): Option[Array[String]] {
+        internalGet(self, name, lower) {_.grabArray().map {"" + _.grabString()}}
+    }
+
+    getInstantArray(name: String, lower: Bool = True): Option[Array[Instant]] {
+        internalGet(self, name, lower) {_.grabArray().map {Instant(Duration(_.call0("getTime").grabInt() * 0.001))}}
+    }
+
+    getBufferArray(name: String, lower: Bool = True): Option[Array[Buffer]] {
+        internalGet(self, name, lower) {_.grabArray().map {_.grabBuffer()}}
+    }
+
+}
+
+internalGet[T](row: PgRow, name: String, lower: Bool, body: JsValue => T): Option[T] {
+    let n = if(lower) {name.lower()} else {name}
+    if(!row.jsValue.hasOwn(n)) {panic("Column not found in result: " + n)}
+    let value = row.jsValue.get(n)
+    if(!value.isNull()) {Some(body(value))} else {None}
+}
+
+internalRunStatement(statement: PgStatement, body: Option[PgRow => Bool]): Int {
+    UnsafeJs.throwIfCancelled()
+    let pair = internalParseParameters(statement.sql)
+    let parameters = internalCheckParameters(pair.second, statement.parameters)
+    let result = UnsafeJs.await { statement.connection.grab().jsValue.call2("query", pair.first, parameters) }
+    body.{
+        | None =>
+            result.get("rowCount").grabInt()
+        | Some(f) =>
+            let all = result.get("rows").grabArray().toList().all { row =>
+                f(PgRow(row))
+            }
+            if(all) {1} else {0}
+    }
+}
+
+internalBatchStatements(
+    connection: PgConnection,
+    statements: List[PgStatement],
+    body: Option[PgRow => Bool],
+    endBody: Option[() => Unit]
+): List[Int] {
+    let sqlCache = statements.map {s => Pair(s.sql, s.sql)}.group().map {sql, list =>
+        let pair = internalParseParameters(sql)
+        let prepared = if(list.size() >= 10) {
+            let hash = UnsafeJs.import("crypto")
+                .call1("createHash", "md5")
+                .call1("update", pair.first)
+                .call1("update", "ffpgps")
+                .call1("digest", "hex")
+            "ffpgps" + hash.grabString()
+        }
+        Pair(sql, (newSql = pair.first, parameterNames = pair.second, prepared = prepared))
+    }
+    let promises = statements.map { statement =>
+        UnsafeJs.throwIfCancelled()
+        let record = sqlCache.grab(statement.sql)
+        let parameters = internalCheckParameters(record.parameterNames, statement.parameters)
+        let query = UnsafeJs.jsSystem().object()
+            .with("text", record.newSql)
+            .with("values", parameters)
+        connection.jsValue.call1("query", record.prepared.map {query.with("name", _)}.else {query})
+    }
+    let results = promises.map { promise =>
+        UnsafeJs.throwIfCancelled()
+        let result = UnsafeJs.await { promise }
+        UnsafeJs.throwIfCancelled()
+        body.{
+            | None =>
+                result.get("rowCount").grabInt()
+            | Some(f) =>
+                let all = result.get("rows").grabArray().toList().all { row =>
+                    f(PgRow(row))
+                }
+                endBody.each {_()}
+                if(all) {1} else {0}
+        }
+    }
+    results
+}
+
+internalCheckParameters(parameterNames: List[String], parameters: Map[String, JsValue]): Array[JsValue] {
+    let arguments = parameterNames.map { name =>
+        parameters.get(name).else {
+            panic("No value for parameter: " + name)
+        }
+    }.toArray()
+    let unusedParameters = parameters.keys().removeAll(parameterNames.toSet())
+    if(unusedParameters.size() > 0) {
+        panic("Unused parameters: " + unusedParameters.toList().join(", "))
+    }
+    arguments
+}
+
+internalParseParameters(statementSql: String): Pair[String, List[String]] {
+    mutable parameters = []
+    mutable parameterIndexes = [].toMap()
+    mutable i = 0
+    mutable last = 0
+    mutable sql = ""
+    while {i < statementSql.size()} {
+        if(statementSql.grab(i) == '$') {
+            sql = sql + statementSql.slice(last, i)
+            i += 1
+            last = i
+            if(statementSql.grab(i) == '$') {
+                i += 1
+            } else {
+                while {i < statementSql.size() && statementSql.grab(i).isAsciiLetterOrDigit()} {
+                    i += 1
+                }
+                let name = statementSql.slice(last, i)
+                if(name != "") {
+                    let index = parameterIndexes.get(name).else {
+                        let newIndex = parameterIndexes.size() + 1
+                        parameterIndexes = parameterIndexes.add(name, newIndex)
+                        parameters = [name, ...parameters]
+                        newIndex
+                    }
+                    sql = sql + "$" + index
+                    last = i
+                }
+            }
+        } else {
+            i += 1
+        }
+    }
+    sql = sql + statementSql.slice(last, i)
+    Pair(sql, parameters.reverse())
+}
+
+main(system: NodeSystem): Unit {
+
+    let pool = makePool(
+        system = system
+        host = system.arguments().grab(0)
+        database = system.arguments().grab(1)
+        user = system.arguments().grab(2)
+        password = {system.arguments().grab(3)}
+    )
+
+    pool.transaction {connection =>
+        let parties = connection.statement("""
+            select name, listCode, entityId
+            from election."PartyRow"
+            where entityId < $maxEntityId
+        """)
+            .withInt("maxEntityId", 200)
+            .map {row =>
+                (
+                    name = row.getString("name").grab()
+                    listCode = row.getString("listCode").grab()
+                    entityId = row.getInt("entityId").grab()
+                )
+            }
+
+        connection.batchMap(
+            parties.map {item =>
+                connection.statement("""
+                    select id
+                    from election."PartyRow"
+                    where name = $name and listCode = $listCode and entityId = $entityId
+                """)
+                    .withString("name", item.name)
+                    .withString("listCode", item.listCode)
+                    .withInt("entityId", item.entityId)
+            }
+        ) {row =>
+            //Log.debug(row)
+        }
+
+    }
+}

package/unsafejs/.firefly/package.ff

@@ -0,0 +1 @@
+package ff:unsafejs:0.0.0

package/unsafejs/UnsafeJs.ff

@@ -0,0 +1,19 @@
+jsSystem(): JsSystem
+    target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
+    target js sync "return typeof globalThis !== 'undefined' ? globalThis : window"
+
+import(module: String): JsValue
+    // Replaced by the compiler ~ hoisted top level import - dynamic imports not currently supported
+    target js sync "throw Error('Dynamic JS imports are not currently supported.')"
+
+await[T](body: () => T): T // This is never actually called async, but will be rewitten by the compiler
+    // Replaced by the compiler
+    target js sync "return body_()"
+
+throwIfCancelled(): Unit
+    // Replaced by the compiler
+    target js sync ""
+
+cancelled(): Bool
+    // Replaced by the compiler
+    target js sync "return false"

package/vscode/.vscode/launch.json

@@ -0,0 +1,18 @@
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "extensionHost",
+			"request": "launch",
+			"name": "Launch Client",
+			"runtimeExecutable": "${execPath}",
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/client/out/**/*.js"],
+			"env": {"FIREFLY_HOME": "${workspaceFolder}/.."},
+			"preLaunchTask": {
+				"type": "npm",
+				"script": "watch"
+			}
+		}
+	]
+}

package/vscode/.vscode/tasks.json

@@ -0,0 +1,33 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"type": "npm",
+			"script": "compile",
+			"group": "build",
+			"presentation": {
+				"panel": "dedicated",
+				"reveal": "never"
+			},
+			"problemMatcher": [
+				"$tsc"
+			]
+		},
+		{
+			"type": "npm",
+			"script": "watch",
+			"isBackground": true,
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"presentation": {
+				"panel": "dedicated",
+				"reveal": "never"
+			},
+			"problemMatcher": [
+				"$tsc-watch"
+			]
+		}
+	]
+}

package/vscode/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Joakim Ahnfelt-Rønne, Michael Werk Ravnsmed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vscode/Prepublish.ff

@@ -0,0 +1,15 @@
+nodeMain(system: NodeSystem) {
+    if(!system.path(".").endsWith(["vscode"])) {
+        panic("Must stand in the Firefly vscode/ directory.")
+    }
+    let fireflyOutputPath = system.path("firefly")
+    if(fireflyOutputPath.exists()) {fireflyOutputPath.delete()}
+    fireflyOutputPath.createDirectory()
+    system.path("../output").copyTo(fireflyOutputPath.slash("output"))
+    system.path("../compiler").copyTo(fireflyOutputPath.slash("compiler"))
+    system.path("../core").copyTo(fireflyOutputPath.slash("core"))
+    system.path("../lsp").copyTo(fireflyOutputPath.slash("lsp"))
+    system.path("../.firefly-workspace").copyTo(fireflyOutputPath.slash(".firefly-workspace"))
+    system.path("../package.json").copyTo(fireflyOutputPath.slash("package.json"))
+    system.path("../node_modules").copyTo(fireflyOutputPath.slash("node_modules"))
+}

package/vscode/README.md

@@ -0,0 +1,17 @@
+# Firefly language support
+
+This extension adds support for the Firefly programming language (`.ff` files). It should work out of the box with no configuration, and comes with the following features:
+
+- Autocompletion
+- Go to definition
+- Find references
+- Signature help
+- Symbol renaming
+- Document and workspace symbols
+- Show type on hover
+- Diagnostics`*`
+
+`*` Diagnostics don't currently update automatically when included files have been edited. It's disabled for performance reasons, and we're working on a solution.
+
+You can run `.ff` main files via the usual *Run and Debug* side panel - just choose *create a launch.json file*. After that you can also press *F5* to run the currently open file.
+