firefly-compiler 0.6.21 → 0.6.24

package/.vscode/settings.json

@@ -1,5 +1,5 @@
 {
     "editor.suggest.showWords": false,
-    "firefly.trace.server": "messages",
+    "firefly.trace.server": "verbose",
     "editor.trimAutoWhitespace": false
 }

package/compiler/Inference.ff

@@ -819,12 +819,28 @@ extend self: Inference {
                 self.unification.unify(term.at, selfParameter.valueType, recordType)
                 let arguments = self.inferArguments(term.at, name, environment, signature.parameters.dropFirst(), e.arguments)
                 self.unification.affect(term.at, signature.effect, environment.effect)
-                e.ECall(
+                let result = e.ECall(
                     target = StaticCall(name, instanceCall = False, tailCall = tailCall)
                     typeArguments = instantiation.map {_.second}
                     arguments = [selfArgument, ...arguments]
                     effect = signature.effect
                 )
+                if(self.lspHook.sql) {
+                    if(name == "ff:postgresql/Pg.PgConnection_statement") {
+                        self.lspHook.sqlStrings.push(result)
+                    } elseIf {name == "ff:postgresql/Pg.PgStatement_map"} {
+                        self.lspHook.sqlStrings.push(result)
+                    } elseIf {name == "ff:postgresql/Pg.PgStatement_each"} {
+                        self.lspHook.sqlStrings.push(result)
+                    } elseIf {name == "ff:postgresql/Pg.PgStatement_any"} {
+                        self.lspHook.sqlStrings.push(result)
+                    } elseIf {name == "ff:postgresql/Pg.PgStatement_all"} {
+                        self.lspHook.sqlStrings.push(result)
+                    } elseIf {name == "ff:postgresql/Pg.PgStatement_run"} {
+                        self.lspHook.sqlStrings.push(result)
+                    }
+                }
+                result
             | _ => fail(term.at, "Call expected")
         }
     }

package/compiler/LspHook.ff

@@ -8,19 +8,29 @@ class LspHook(
     insertIdentifier: Bool
     trackSymbols: Bool
     arrayOfResults: Array[ResultHook]
+    sql: Bool
+    sqlStrings: Array[Term]
 )
 
-disabled(): LspHook {
-    new(None, None, False, False)
+disabled(sql: Bool = False): LspHook {
+    new(None, None, False, False, sql)
 }
 
-new(at: Option[Location], definedAt: Option[Location], insertIdentifier: Bool, trackSymbols: Bool): LspHook {
+new(
+    at: Option[Location]
+    definedAt: Option[Location]
+    insertIdentifier: Bool
+    trackSymbols: Bool
+    sql: Bool = False
+): LspHook {
     LspHook( // Default dummy values instead of Option[Location] to speed up location hit check
         at = at.else {Location("^lsp", -7, -7)}
         definedAt = definedAt.else {Location("^lsp", -7, -7)}
         insertIdentifier = insertIdentifier
         trackSymbols = trackSymbols
-        arrayOfResults = [].toArray()
+        arrayOfResults = Array.new()
+        sql = sql
+        sqlStrings = Array.new()
     )
 }
 
@@ -200,4 +210,4 @@ showHook(hook: ResultHook): String {
     | ResolveSymbolHook(symbol, annotation, _) => "ResolveSymbolHook(...)"
     | ResolveTypeHook(types, typeGenerics, symbol, explicitType) => "ResolveTypeHook(...)"
     | ResolveVariantFieldHook(symbol, type, commonField) => "ResolveVariantFieldHook(...)"
-}
+}

package/core/Ordering.ff

@@ -91,7 +91,7 @@ instance List[T: Order]: Order {
             ordering = compare(x.grab(i), y.grab(i))
             i += 1
         }
-        if(ordering != OrderingSame) {
+        if(ordering == OrderingSame) {
             fromInt(x.size() - y.size())
         } else {
             ordering

package/experimental/inceptron/Run.ff

@@ -0,0 +1,47 @@
+nodeMain(system: NodeSystem) {
+    let secretKey = system.arguments().grab(0)
+    let json = Json->(
+        model = "moonshotai/Kimi-K2.6"
+        messages = [
+            Json->(role = "user", content = "Can you summerize firefly-lang.org for me.")
+        ]
+        tools = [
+            Json->(type = "function", function = Json->(
+                name = "web_search"
+                description = "Search the web for up-to-date information, images, or data based on a query."
+                parameters = Json->(
+                    type = "object"
+                    properties = Json->(
+                        query = Json->(
+                            type = "string"
+                            description = "The search query to look up on the web."
+                        )
+                    )
+                    required = ["query"]
+                )
+            ))
+            Json->(type = "function", function = Json->(
+                name = "web_fetch"
+                description = "Fetch the contents of a URL using a GET request."
+                parameters = Json->(
+                    type = "object"
+                    properties = Json->(
+                        url = Json->(
+                            type = "string"
+                            description = "The URL to fetch."
+                        )
+                    )
+                    required = ["url"]
+                )
+            ))
+        ]
+    )
+    // To give a tool result: {"role": "tool", "content": "... e.g. encoded JSON", "tool_call_id": "call_123"}
+    system.httpClient().post("https://api.inceptron.io/v1/chat/completions", [
+        Pair("Content-Type", "application/json")
+        Pair("Authorization", "Bearer " + secretKey)
+    ], json.write().toBuffer()) {response =>
+        Log.debug("Response ok? " + Show.show(response.ok()))
+        Log.debug(response.readJson().write(Some("  ")))
+    }
+}

package/experimental/mattis/Tree.ff

@@ -0,0 +1,44 @@
+nodeMain(system: NodeSystem) {
+    
+    let x: Float = 123.0
+    let s: String = "Hi"
+    let p = s + x
+    let r1: Int = 123.8.round().toInt()
+    Log.show(p)
+    
+    let player = Human("RawFood23", None)
+    let bot = Bot(42)
+    
+    let players: List[Player] = [
+        Human("RawFood23", None)
+        Human("Nokoline123", Some(system.date()))
+        bot
+        
+    ]
+        
+    players.each {
+        | Human(name, None) => 
+            Log.trace(name + " is in lobby")
+        | Human(name, Some(joined)) => 
+            Log.trace(name + " joined at " + Show.show(joined))
+        | Bot(n) =>
+            Log.trace("Bot nr. " + n)
+    }
+    
+    let player2 =  (name = "Jogn", age = 11)
+
+}
+
+addPlayer(player: Player) {
+    
+}
+
+data Player {
+    Human(
+        name: String
+        joined: Option[Date]
+    )
+    Bot(
+        number: Int
+    )
+}

package/experimental/tests/TestListOrdering.ff

@@ -0,0 +1,7 @@
+nodeMain(system: NodeSystem) {
+    
+    let result = Ordering.compare([1], [2])
+    Log.debug(Show.show(result.toInt()))
+    
+    
+}

package/experimental/tests/TestOrder.ff

@@ -0,0 +1,4 @@
+nodeMain(system: NodeSystem) {
+    let result = Ordering.compare([1], [2])
+    Log.trace(Show.show(result.toInt()))
+}

package/experimental/tests/TestSql.ff

@@ -0,0 +1,18 @@
+dependency ff:postgresql:0.0.0
+
+import Pg from ff:postgresql
+
+
+testSql(connection: PgConnection): List[String] {
+    connection.statement("""
+        -- Comment
+        select *, benefit, g.deleted, 'Fooo', 123
+        from guide."GuideHistory" g
+        join guide."GuideDepartment" GD on g.id = GD.guideid
+        where g.benefit is not null and $name = '0x42' and true
+    """)
+    .withInt("name", 34)
+    .map {row => 
+        row.getString("name").grab()
+    }
+}

package/lsp/.firefly/package.ff

@@ -1 +1,2 @@
 dependency ff:compiler:0.0.0
+dependency ff:postgresql:0.0.0

package/lsp/CompletionHandler.ff

@@ -3,6 +3,9 @@ import Unification from ff:compiler
 import Environment from ff:compiler
 import Syntax from ff:compiler
 import Handler
+import Sql
+import SqlSuggestion
+import SqlStatement
 
 data CompletionInfo(
     label: String
@@ -15,6 +18,7 @@ data CompletionInfo(
     expectedType: Option[Type]
     secondarySort: Int = 5
     insertion: Option[Pair[Int, String]] = None
+    sql: Bool = False
 )
 
 data ImportSymbolsInfo(
@@ -35,7 +39,10 @@ handleCompletion(
     toplevel: Bool
     followedByOpenBracket: Bool
     importSymbols: ImportSymbolsInfo
+    sqlStatement: Option[Pair[Location, SqlStatement]]
+    sqlData: SqlData
 ): Json {
+    sqlStatement.map {| Pair(l, s) => completionsToJson(sqlCompletion(l, s, sqlData))}.else:
     let topLevelCompletions = if(!toplevel) {[]} else {toplevelCompletion(lspHook)}
     let patternCompletions = lspHook.results().collectFirst {
         | InferPatternHook h =>
@@ -195,10 +202,14 @@ completionsToJson(completions: List[CompletionInfo]): Json {
             let isDefinition = ["let ", "mutable ", "function "].any {i.snippet.startsWith(_)}
             let isParameter = i.snippet.endsWith(" = ")
             let isImport = i.documentation == "// Imports this module"
-            let sortText = if(isParameter || isDefinition || isImport) {0} else {9 - (
-                isVariable.toInt() + isUnqualified.toInt() +
-                isAlpha.toInt() + isLower.toInt() + isMember.toInt()
-            )} + if(isMember) {"1"} else {"0"} + i.secondarySort + i.label.lower()
+            let sortText = if(i.sql && i.extra == "") {
+                i.secondarySort + i.label.lower()
+            } else {
+                if(isParameter || isDefinition || isImport) {0} else {9 - (
+                    isVariable.toInt() + isUnqualified.toInt() +
+                    isAlpha.toInt() + isLower.toInt() + isMember.toInt()
+                )} + if(isMember) {"1"} else {"0"} + i.secondarySort + i.label.lower()
+            }
             let preselect = !isDefinition && Pair(i.type, i.expectedType).{
                 | Pair(TConstructor(_, n1, _), Some(TConstructor(_, n2, _))) => n1 == n2
                 | _ => False
@@ -206,6 +217,16 @@ completionsToJson(completions: List[CompletionInfo]): Json {
             Json.object()
                 // Namespace or Property or Constructor or EnumMember or Constructor or Method/Function or Field/Variable
                 .with("kind"
+                    if(i.sql) {
+                        if(i.secondarySort == 1) {15} else:
+                        if(i.secondarySort == 2) {23} else:
+                        if(i.secondarySort == 3) {7} else:
+                        if(i.secondarySort == 4) {5} else:
+                        if(i.secondarySort == 5) {6} else:
+                        if(i.secondarySort == 8) {3} else:
+                        if(i.secondarySort == 9) {15} else:
+                        9
+                    } else:
                     if(isImport) {2} else:
                     if(shownType == "") {3} else:
                     if(isParameter) {10} else:
@@ -218,14 +239,18 @@ completionsToJson(completions: List[CompletionInfo]): Json {
                 .with("preselect", preselect)
                 .with("label", i.label)
                 .with("labelDetails", Json.object()
-                    .with("detail", i.extra + if(shownType == "") {""} else {": " + shownType})
+                    .with("detail", if(i.sql) {i.extra} else {
+                        i.extra + if(shownType == "") {""} else {": " + shownType}
+                    })
                     .with("description", i.more)
                 )
                 .with("insertText", i.snippet)
                 .with("insertTextFormat", 2 /* Snippet */)
                 .with("documentation", Json.object()
                     .with("kind", "markdown")
-                    .with("value", "```\n" + i.documentation + "\n```")
+                    .with("value", 
+                        if(i.sql) {"```sql\n"} else {"```\n"} + i.documentation + "\n```"
+                    )
                 )
                 .with("additionalTextEdits", i.insertion.toList().map {| Pair(line, text) => Json.object()
                     .with("range", Json->(
@@ -237,6 +262,87 @@ completionsToJson(completions: List[CompletionInfo]): Json {
         })
 }
 
+sqlCompletion(at: Location, sqlStatement: SqlStatement, data: SqlData): List[CompletionInfo] {
+    let tokens = Sql.tokenize(sqlStatement.string)
+    let line = 1 + at.line - sqlStatement.at.line
+    let column = if(at.line == sqlStatement.at.line) {1 + at.column - sqlStatement.at.column} else {at.column}
+    let suggestions = SqlSuggestion.suggest(data, tokens, line, column)
+    function fixQuotes(snippet: String): String {
+        if(suggestions.second) {snippet.replace("\"", "")} else {snippet}
+    }
+    suggestions.first.map {
+        | SqlSuggestionFunction(l, signature, documentation)@suggestion =>
+            CompletionInfo(
+                label = l
+                extra = signature
+                more = ""
+                snippet = fixQuotes(Sql.quote(l) + "($0)")
+                member = False
+                type = TConstructor(Location("", 0, 0), "", [])
+                documentation = documentation
+                expectedType = None
+                sql = True
+                secondarySort = suggestion.secondarySort()
+            )
+        | SqlSuggestionJoin(l, schema, snippet)@suggestion =>
+            CompletionInfo(
+                label = l
+                extra = ""
+                more = schema
+                snippet = fixQuotes(snippet)
+                member = False
+                type = TConstructor(Location("", 0, 0), "", [])
+                documentation = snippet
+                expectedType = None
+                sql = True
+                secondarySort = suggestion.secondarySort()
+            )
+        | SqlSuggestionRegular(l, display, documentation)@suggestion =>
+            CompletionInfo(
+                label = l
+                extra = ""
+                more = display
+                snippet = fixQuotes(Sql.quote(l))
+                member = False
+                type = TConstructor(Location("", 0, 0), "", [])
+                documentation = documentation
+                expectedType = None
+                sql = True
+                secondarySort = suggestion.secondarySort()
+            )
+        | SqlSuggestionColumnNames(required, columns)@suggestion =>
+            let comment = 
+                if(required) {"-- required columns\n"} elseIf {columns.size() > 1} {"-- all columns\n"} else {""}
+            CompletionInfo(
+                label = columns.map {_.first}.join(", ")
+                extra = ""
+                more = ""
+                snippet = fixQuotes(columns.map {Sql.quote(_.first)}.join(", "))
+                member = False
+                type = TConstructor(Location("", 0, 0), "", [])
+                documentation = comment + columns.map {_.second}.join("\n")
+                expectedType = None
+                sql = True
+                secondarySort = suggestion.secondarySort()
+            )
+        | SqlSuggestionColumnSetters(columns)@suggestion =>
+            CompletionInfo(
+                label = columns.map {_.first + " = "}.join(", ")
+                extra = ""
+                more = ""
+                snippet = fixQuotes(columns.pairs().map {| Pair(i, c) => 
+                    Sql.quote(c.first) + " = " + if(i == 0) {"$0"} else {""}
+                }.join(",\n"))
+                member = False
+                type = TConstructor(Location("", 0, 0), "", [])
+                documentation = columns.map {_.second}.join("\n")
+                expectedType = None
+                sql = True
+                secondarySort = suggestion.secondarySort()
+            )
+    }
+}
+
 importCompletion(moduleKeys: List[ModuleKey]): List[CompletionInfo] {
     moduleKeys.map {moduleKey =>
         let label = moduleKey.folders.map {_ + "."}.join() + moduleKey.name