firefly-compiler 0.6.20 → 0.6.24

package/lsp/Handler.ff

@@ -10,10 +10,15 @@ 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
@@ -23,10 +28,20 @@ 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
@@ -57,8 +72,12 @@ 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.{
@@ -126,6 +145,8 @@ 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())
             | _ => 
@@ -160,6 +181,10 @@ 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", [
@@ -212,6 +237,15 @@ 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")
@@ -244,7 +278,8 @@ extend self: Handler {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
+        let lspHook = LspHook.disabled(sql = True)
+        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
         let diagnostics = errors.filter {_.at.file == path.absolute()}.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
             Json.object()
@@ -252,10 +287,101 @@ 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)
+            .with("diagnostics", [...diagnostics, ...sqlDiagnistics])
     }
     
     handleClearDiagnostic(system: NodeSystem, parameters: Map[String, Json]): List[Json] {
@@ -310,6 +436,63 @@ 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 =>
@@ -407,7 +590,9 @@ extend self: Handler {
             line = token.startLine
             column = token.startColumn
         )
-        let lspHook = LspHook.new(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
+        let lspHook = LspHook.new(
+            at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False, sql = True
+        )
         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) => 
@@ -416,6 +601,7 @@ 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
@@ -425,6 +611,8 @@ extend self: Handler {
                 importSymbols = importSymbols.first
                 importLine = importSymbols.second
             )
+            sqlStatement = sqlStatement.map {Pair(location, _)}
+            sqlData = self.sqlData.else {SqlData([], [], [], [])}
         )
         Result(o.write())
     }
@@ -792,9 +980,19 @@ 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,6 +39,11 @@ 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/lsp/SemanticTokenTypes.ff

@@ -0,0 +1,62 @@
+data SemanticTokenTypes(
+	namespace: Pair[String, Int]
+    type: Pair[String, Int]
+	class: Pair[String, Int]
+	enum: Pair[String, Int]
+	interface: Pair[String, Int]
+	struct: Pair[String, Int]
+	typeParameter: Pair[String, Int]
+	parameter: Pair[String, Int]
+	variable: Pair[String, Int]
+	property: Pair[String, Int]
+	enumMember: Pair[String, Int]
+	event: Pair[String, Int]
+	function: Pair[String, Int]
+	method: Pair[String, Int]
+	macro: Pair[String, Int]
+	keyword: Pair[String, Int]
+	modifier: Pair[String, Int]
+	comment: Pair[String, Int]
+	string: Pair[String, Int]
+	number: Pair[String, Int]
+	regexp: Pair[String, Int]
+	operator: Pair[String, Int]
+	decorator: Pair[String, Int]
+	label: Pair[String, Int]
+)
+
+new(): Pair[SemanticTokenTypes, List[String]] {
+    let names = Array.new()
+    function add(name: String): Pair[String, Int] {
+        let index = names.size()
+        names.push(name)
+        Pair(name, index)
+    }
+    let types = SemanticTokenTypes(
+        namespace = add("namespace")
+        type = add("type")
+        class = add("class")
+        enum = add("enum")
+        interface = add("interface")
+        struct = add("struct")
+        typeParameter = add("typeParameter")
+        parameter = add("parameter")
+        variable = add("variable")
+        property = add("property")
+        enumMember = add("enumMember")
+        event = add("event")
+        function = add("function")
+        method = add("method")
+        macro = add("macro")
+        keyword = add("keyword")
+        modifier = add("modifier")
+        comment = add("comment")
+        string = add("string")
+        number = add("number")
+        regexp = add("regexp")
+        operator = add("operator")
+        decorator = add("decorator")
+        label = add("label")
+    )
+    Pair(types, names.drain())
+}