firefly-compiler 0.6.24 → 0.6.30

package/.vscode/settings.json

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

package/compiler/Inference.ff

@@ -819,28 +819,12 @@ 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)
-                let result = e.ECall(
+                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,29 +8,19 @@ class LspHook(
     insertIdentifier: Bool
     trackSymbols: Bool
     arrayOfResults: Array[ResultHook]
-    sql: Bool
-    sqlStrings: Array[Term]
 )
 
-disabled(sql: Bool = False): LspHook {
-    new(None, None, False, False, sql)
+disabled(): LspHook {
+    new(None, None, False, False)
 }
 
-new(
-    at: Option[Location]
-    definedAt: Option[Location]
-    insertIdentifier: Bool
-    trackSymbols: Bool
-    sql: Bool = False
-): LspHook {
+new(at: Option[Location], definedAt: Option[Location], insertIdentifier: Bool, trackSymbols: Bool): 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 = Array.new()
-        sql = sql
-        sqlStrings = Array.new()
+        arrayOfResults = [].toArray()
     )
 }
 
@@ -210,4 +200,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/lsp/.firefly/package.ff

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

package/lsp/CompletionHandler.ff

@@ -3,9 +3,6 @@ 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
@@ -18,7 +15,6 @@ data CompletionInfo(
     expectedType: Option[Type]
     secondarySort: Int = 5
     insertion: Option[Pair[Int, String]] = None
-    sql: Bool = False
 )
 
 data ImportSymbolsInfo(
@@ -39,10 +35,7 @@ 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 =>
@@ -202,14 +195,10 @@ 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(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 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 preselect = !isDefinition && Pair(i.type, i.expectedType).{
                 | Pair(TConstructor(_, n1, _), Some(TConstructor(_, n2, _))) => n1 == n2
                 | _ => False
@@ -217,16 +206,6 @@ 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:
@@ -239,18 +218,14 @@ completionsToJson(completions: List[CompletionInfo]): Json {
                 .with("preselect", preselect)
                 .with("label", i.label)
                 .with("labelDetails", Json.object()
-                    .with("detail", if(i.sql) {i.extra} else {
-                        i.extra + if(shownType == "") {""} else {": " + shownType}
-                    })
+                    .with("detail", 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", 
-                        if(i.sql) {"```sql\n"} else {"```\n"} + i.documentation + "\n```"
-                    )
+                    .with("value", "```\n" + i.documentation + "\n```")
                 )
                 .with("additionalTextEdits", i.insertion.toList().map {| Pair(line, text) => Json.object()
                     .with("range", Json->(
@@ -262,87 +237,6 @@ 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

package/lsp/Handler.ff

@@ -10,15 +10,10 @@ import Unification from ff:compiler
 import LspHook from ff:compiler
 import ModuleCache from ff:compiler
 import DependencyLock from ff:compiler
-import Pg from ff:postgresql
 import HoverHandler
 import CompletionHandler
 import SignatureHelpHandler
 import SymbolHandler
-import SemanticTokenTypes
-import Sql
-import SqlStatement
-
 
 capability Handler(
     fireflyPath: Path
@@ -28,20 +23,10 @@ capability Handler(
     mutable responseCache: Map[TokenRequestCacheKey, ResultOrError]
     mutable fileSymbolsCache: Map[String, List[DocumentSymbol]]
     mutable importSymbolsCache: Pair[String, List[ImportSymbolInfo]]
-    mutable sqlConnectionString: Option[String]
-    mutable sqlData: Option[SqlData]
-    mutable sqlConnectionPool: Option[PgPool]
-    sqlDiagnosticsCache: StringMap[Map[String, Option[SqlError]]]
-    sqlLock: Lock
     moduleCache: ModuleCache
     dependencyLock: DependencyLock
 )
 
-data SqlCacheKey(
-    sql: String
-    parameters: Option[List[SqlParameter]]
-)
-
 data TokenRequestCacheKey(
     method: String
     targetAt: Location
@@ -72,12 +57,8 @@ data TokenLocation(
 
 data Definition(at: Location, name: String, local: Bool)
 
-data SqlError(token: SqlToken, message: String)
 
 extend self: Handler {
-    
-    
-
 
     handleNotification(system: NodeSystem, method: String, parameters: Map[String, Json], version: Int): List[Pair[String, Json]] {
         method.{
@@ -145,8 +126,6 @@ extend self: Handler {
                 self.printTime(system.mainTask(), "handleWorkspaceSymbol") {
                     self.handleWorkspaceSymbol(system, parameters)
                 }
-            | "textDocument/semanticTokens/full" =>
-                self.handleSemanticTokensFull(system, parameters, version)
             | "shutdown" => 
                 Result(Json.null().write())
             | _ => 
@@ -181,10 +160,6 @@ extend self: Handler {
 
     handleInitialize(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         self.rootPath = parameters.grab("rootUri").getString().map {system.pathFromUrl(_)}
-        self.sqlConnectionString = parameters.get("initializationOptions").{
-            | Some(opts) => opts.getField("sqlConnectionString").map {_.grabString()}.filter {_ != ""}
-            | None => None
-        }
 
         let anyFireflyFile = Json.object()
             .with("filters", [
@@ -237,15 +212,6 @@ extend self: Handler {
                     )
                 )*/
                 .with("renameProvider", True)
-                .with("semanticTokensProvider", Json.object()
-                    .with("legend", Json.object()
-                        .with("tokenTypes", SemanticTokenTypes.new().second)
-                        .with("tokenModifiers", Json.array([]))
-                    )
-                    .with("full", Json.object()
-                        .with("delta", False)
-                    )
-                )
             )
             .with("serverInfo", Json.object()
                 .with("name", "Firefly Language Server")
@@ -278,8 +244,7 @@ extend self: Handler {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let lspHook = LspHook.disabled(sql = True)
-        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
+        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
         let diagnostics = errors.filter {_.at.file == path.absolute()}.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
             Json.object()
@@ -287,101 +252,10 @@ extend self: Handler {
                 .with("severity", 1)
                 .with("message", message)
         }
-        
-        let sqlStatements = SqlStatement.extractStatements(lspHook.sqlStrings.toList())
-        let sqlDiagnistics = if(sqlStatements.isEmpty()) {[]} else {
-            if(self.sqlConnectionString.isEmpty()) {
-                sqlStatements.map {
-                    | SqlStatement(_, at, _, _) =>
-                        let tokenLocation = self.findToken(system, at)
-                        Json.object()
-                            .with("range", self.tokenLocationToLspRange(tokenLocation))
-                            .with("severity", 3)
-                            .with("message", "Configure firefly.sqlConnectionString to enable SQL diagnostics")
-                            .with("source", "firefly")
-                }
-            } else:
-            self.sqlLock.do {
-                mutable sqlCache = self.sqlDiagnosticsCache.getOrSet(path.absolute()) {Map.new()}
-                mutable seenSql = Set.new()
-                let issues = try {
-                    let pool = self.getSqlConnectionPool(system)
-                    pool.transaction(readOnly = True, body = {connection =>
-                        sqlStatements.collect {
-                            | SqlStatement(_, at, sql, parameters) => 
-                                let cacheKey = Show.show(SqlCacheKey(sql, parameters))
-                                seenSql = seenSql.add(cacheKey)
-                                let sqlError = sqlCache.get(cacheKey).else {
-                                    let error = Sql.buildExplainStatement(sql, parameters).flatMap {
-                                        | ExplainedStatement(explainSql, deltas, usedParameters) =>
-                                            let missingParameters = parameters.map {parsedParameters => 
-                                                usedParameters.filter {| Pair(used, o) => parsedParameters.all {passed => passed.name != used}}
-                                            }.else {[]}
-                                            try {
-                                                connection.statement(explainSql).map {_ => }
-                                                missingParameters.first().map {| Pair(name, position) =>
-                                                    let tokens = Sql.tokenize(sql)
-                                                    let t = tokens.find {_.startOffset >= position - 1}.else {tokens.grabLast()} // TODO
-                                                    SqlError(t, "Parameter not defined: " + name)
-                                                }
-                                            } catchAny {e => 
-                                                let errorMessage = e.message()
-                                                system.writeErrorLine(Json(e!).write())
-                                                let errorPosition = if(e!->position.nullish()) {0} else {
-                                                    let position = e!->position.grabString().grabInt()
-                                                    position + deltas.filter {_.first < position}.map {_.second}.foldLeft(0) {_ + _}
-                                                }
-                                                let tokens = Sql.tokenize(sql)
-                                                let t = tokens.find {_.startOffset >= errorPosition - 1}.else {tokens.grabLast()} // TODO
-                                                Some(SqlError(t, errorMessage))
-                                            }
-                                    }
-                                    sqlCache = sqlCache.add(cacheKey, error)
-                                    error
-                                }
-                                sqlError.map {e =>
-                                    let absoluteLine = at.line - 1 + e.token.startLine - 1 + 1
-                                    let absoluteColumnExtra = if(e.token.at().line == 1) {at.column - 1} else {0} 
-                                    let absoluteColumn = e.token.startOffset - e.token.startLineOffset + absoluteColumnExtra + 1
-                                    let tokenLocation = TokenLocation(
-                                        file = at.file
-                                        startLine = absoluteLine
-                                        startColumn = absoluteColumn
-                                        endLine = absoluteLine
-                                        endColumn = absoluteColumn + (e.token.stopOffset - e.token.startOffset)
-                                        raw = e.token.raw()
-                                        followedByLeftBracket = False
-                                    )
-                                    Json.object()
-                                        .with("range", self.tokenLocationToLspRange(tokenLocation))
-                                        .with("severity", 1)
-                                        .with("message", e.message)
-                                }
-                            | _ => None
-                        }
-                    })
-                } catchAny {error =>
-                    system.writeErrorLine("Error while running SQL diagnostics: " + error.message())
-                    system.writeErrorLine(error.stack())
-                    []
-                }
-                if(seenSql.size() == 0) {
-                    self.sqlDiagnosticsCache.remove(path.absolute())
-                } else {
-                    sqlCache.keys().each {
-                        | cachedSql {!seenSql.contains(cachedSql)} => sqlCache = sqlCache.remove(cachedSql)
-                        | _ => 
-                    }
-                    self.sqlDiagnosticsCache.set(path.absolute(), sqlCache)
-                }
-                issues
-            }
-        }
-        
         Json.object()
             .with("uri", uri)
             .with("version", parameters.grab("textDocument").field("version"))
-            .with("diagnostics", [...diagnostics, ...sqlDiagnistics])
+            .with("diagnostics", diagnostics)
     }
     
     handleClearDiagnostic(system: NodeSystem, parameters: Map[String, Json]): List[Json] {
@@ -436,63 +310,6 @@ extend self: Handler {
                 symbols
         }
     }
-    
-    handleSemanticTokensFull(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
-        let js = system.js()
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        let fireflyPath = system.path(".")
-        let lspHook = LspHook.disabled(sql = True)
-        self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
-        let sqlStatements = SqlStatement.extractStatements(lspHook.sqlStrings.toList())
-        if(!sqlStatements.isEmpty() && self.sqlData.isEmpty()) {
-            self.sqlData = Some(SqlData([], [], [], []))
-            system.mainTask().spawn {_ =>
-                try {
-                    let pool = self.getSqlConnectionPool(system)
-                    let data = Sql.load(system, pool)
-                    self.sqlData = Some(data)
-                } catchAny {error =>
-                    system.writeErrorLine("Error while running Sql.load: " + error.message())
-                }
-            }
-        }
-        mutable lastAbsoluteLine = -1
-        mutable lastAbsoluteColumn = 0
-        let tokens = sqlStatements.flatMap {
-            | SqlStatement(_, at, sql, _) => 
-                let tokens = Sql.tokenize(sql)
-                tokens.map {token => 
-                    let absoluteLine = at.line - 1 + token.startLine - 1
-                    let absoluteColumnExtra = if(token.at().line == 1) {at.column - 1} else {0} 
-                    let absoluteColumn = token.startOffset - token.startLineOffset + absoluteColumnExtra
-                    let length = token.stopOffset - token.startOffset
-                    let relativeLine = if(lastAbsoluteLine != -1) {absoluteLine - lastAbsoluteLine} else {absoluteLine}
-                    let relativeColumn = if(lastAbsoluteLine == absoluteLine) {absoluteColumn - lastAbsoluteColumn} else {absoluteColumn}
-                    let tokenTypes = SemanticTokenTypes.new().first
-                    let tokenType = token.kind.{
-                        | SqlReserved => tokenTypes.keyword.second
-                        | SqlUnreserved => tokenTypes.macro.second
-                        | SqlIdentifier => tokenTypes.variable.second
-                        | SqlNumber => tokenTypes.number.second
-                        | SqlString => tokenTypes.string.second
-                        | SqlOperator => tokenTypes.operator.second
-                        | SqlPunctuation => tokenTypes.operator.second
-                        | SqlComment => tokenTypes.comment.second
-                        | SqlPlaceholder => tokenTypes.typeParameter.second
-                    }
-                    let tokenModifiers = 0
-                    lastAbsoluteLine = absoluteLine
-                    lastAbsoluteColumn = absoluteColumn
-                    [relativeLine, relativeColumn, length, tokenType, tokenModifiers]
-                }
-            | _ => []
-        }
-                
-        let o = Json.object()
-            .with("data", Json.array(tokens.flatten().map(Json.int)))
-        Result(o.write())
-    }
 
     handleWorkspaceSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         self.rootPath.or {Error(-32803 /*Request Failed*/, "Open a folder to enable workspace symbols")}: rootPath =>
@@ -590,9 +407,7 @@ extend self: Handler {
             line = token.startLine
             column = token.startColumn
         )
-        let lspHook = LspHook.new(
-            at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False, sql = True
-        )
+        let lspHook = LspHook.new(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
         let path = system.path(completionAt.file)
         let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
         errors.each {| CompileError(at, message) => 
@@ -601,7 +416,6 @@ extend self: Handler {
         let importSymbols = self.printTime(system.mainTask(), "findModulesToImport") {
             self.findModulesToImport(system, path, lspHook)
         }
-        let sqlStatement = SqlStatement.extractStatements(lspHook.sqlStrings.toList()).find {_.termAt == completionAt}
         let o = CompletionHandler.handleCompletion(
             lspHook = lspHook
             toplevel = completionAt.column == 1
@@ -611,8 +425,6 @@ extend self: Handler {
                 importSymbols = importSymbols.first
                 importLine = importSymbols.second
             )
-            sqlStatement = sqlStatement.map {Pair(location, _)}
-            sqlData = self.sqlData.else {SqlData([], [], [], [])}
         )
         Result(o.write())
     }
@@ -980,19 +792,9 @@ extend self: Handler {
             infer
         )
     }
-    
-    getSqlConnectionPool(system: NodeSystem): PgPool {
-        let connectionString = self.sqlConnectionString.else {
-            throw(LanguageServerException("No SQL connection string configured. Set firefly.sqlConnectionString in VS Code settings."))
-        }
-        self.sqlLock.do {
-            self.sqlConnectionPool.else {
-                let pool = Pg.newPoolFromConnectionString(system, connectionString)
-                self.sqlConnectionPool = Some(pool)
-                pool
-            }
-        }
-    }
-    
 
 }
+
+foo(bb: Int): Int {
+    bb
+}

package/lsp/LanguageServer.ff

@@ -39,11 +39,6 @@ main(system: NodeSystem) {
         responseCache = Map.new()
         fileSymbolsCache = Map.new()
         importSymbolsCache = Pair("", [])
-        sqlConnectionString = None
-        sqlData = None
-        sqlConnectionPool = None
-        sqlLock = system.mainTask().lock()
-        sqlDiagnosticsCache = StringMap.new()
         moduleCache = cache
         dependencyLock = DependencyLock.new(system.mainTask())
     )

package/output/js/ff/compiler/Builder.mjs

@@ -123,7 +123,7 @@ return {root_, packageFile_, files_};
 
 export function build_(system_, emitTarget_, mainModules_, resolvedDependencies_, jsOutputPath_, printMeasurements_, moduleCache_) {
 ff_core_Path.Path_createDirectory(jsOutputPath_, true);
-const compiler_ = ff_compiler_Compiler.new_(emitTarget_, ff_core_NodeSystem.NodeSystem_mainTask(system_), jsOutputPath_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_(false));
+const compiler_ = ff_compiler_Compiler.new_(emitTarget_, ff_core_NodeSystem.NodeSystem_mainTask(system_), jsOutputPath_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_());
 for(let for_a = mainModules_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const moduleKey_ = for_a[for_i];
 ff_compiler_Compiler.Compiler_emit(compiler_, moduleKey_, true)
@@ -377,7 +377,7 @@ pkg_.exec([packageFile_.absolutePath_, "--out-path", outputPath_.absolutePath_,
 
 export async function build_$(system_, emitTarget_, mainModules_, resolvedDependencies_, jsOutputPath_, printMeasurements_, moduleCache_, $task) {
 (await ff_core_Path.Path_createDirectory$(jsOutputPath_, true, $task));
-const compiler_ = (await ff_compiler_Compiler.new_$(emitTarget_, (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), jsOutputPath_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_(false), $task));
+const compiler_ = (await ff_compiler_Compiler.new_$(emitTarget_, (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), jsOutputPath_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_(), $task));
 for(let for_a = mainModules_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const moduleKey_ = for_a[for_i];
 (await ff_compiler_Compiler.Compiler_emit$(compiler_, moduleKey_, true, $task))