wip: show some diagnostics via LSP

Author: PascalHonegger

common/src/main/kotlin/tools/samt/common/Diagnostics.kt

@@ -153,7 +153,6 @@ class DiagnosticMessageBuilder(
 
     fun build(): DiagnosticMessage {
         requireNotNull(message)
-        highlights.sortWith(compareBy({ it.location.start.row }, { it.location.start.col }))
         return DiagnosticMessage(severity, message!!, highlights, annotations)
     }
 }

language-server/src/main/kotlin/tools/samt/ls/SamtLanguageServer.kt

@@ -12,11 +12,17 @@ class SamtLanguageServer : LanguageServer, LanguageClientAware, Closeable {
     private val textDocumentService = SamtTextDocumentService()
     private val logger = Logger.getLogger("SamtLanguageServer")
 
-    override fun initialize(params: InitializeParams): CompletableFuture<InitializeResult> = CompletableFuture.supplyAsync {
-        val capabilities = ServerCapabilities().apply {
-            diagnosticProvider = DiagnosticRegistrationOptions(true, false)
+    override fun initialize(params: InitializeParams): CompletableFuture<InitializeResult> =
+        CompletableFuture.supplyAsync {
+            val capabilities = ServerCapabilities().apply {
+                // TODO support pull-based diagnostics? diagnosticProvider = DiagnosticRegistrationOptions(true, false)
+                setTextDocumentSync(TextDocumentSyncKind.Full)
+            }
+            InitializeResult(capabilities)
         }
-        InitializeResult(capabilities)
+
+    override fun setTrace(params: SetTraceParams?) {
+        // TODO
     }
 
     override fun shutdown(): CompletableFuture<Any> = CompletableFuture.completedFuture(null)

language-server/src/main/kotlin/tools/samt/ls/SamtTextDocumentService.kt

@@ -4,19 +4,48 @@ import org.eclipse.lsp4j.*
 import org.eclipse.lsp4j.services.LanguageClient
 import org.eclipse.lsp4j.services.LanguageClientAware
 import org.eclipse.lsp4j.services.TextDocumentService
-import java.util.concurrent.CompletableFuture
+import tools.samt.common.DiagnosticController
+import tools.samt.common.DiagnosticException
+import tools.samt.common.DiagnosticMessage
+import tools.samt.common.SourceFile
+import tools.samt.lexer.Lexer
+import tools.samt.parser.Parser
+import tools.samt.semantic.SemanticModelBuilder
 import java.util.logging.Logger
+import kotlin.io.path.Path
+import kotlin.io.path.readText
+import tools.samt.common.DiagnosticSeverity as SamtSeverity
+import tools.samt.common.Location as SamtLocation
 
 class SamtTextDocumentService : TextDocumentService, LanguageClientAware {
     private lateinit var client: LanguageClient
     private val logger = Logger.getLogger("SamtTextDocumentService")
 
     override fun didOpen(params: DidOpenTextDocumentParams) {
         logger.info("Opened document ${params.textDocument.uri}")
+
+        val uri = params.textDocument.uri.removePrefix("file://")
+        val messages = compile(uri, Path(uri).readText())
+
+        client.publishDiagnostics(
+            PublishDiagnosticsParams(
+                params.textDocument.uri,
+                messages.mapNotNull { it.toDiagnostic() })
+        )
     }
 
     override fun didChange(params: DidChangeTextDocumentParams) {
         logger.info("Changed document ${params.textDocument.uri}")
+
+        val uri = params.textDocument.uri.removePrefix("file://")
+        val newText = params.contentChanges.firstOrNull()?.text ?: Path(uri).readText()
+        val messages = compile(uri, newText)
+
+        client.publishDiagnostics(
+            PublishDiagnosticsParams(
+                params.textDocument.uri,
+                messages.mapNotNull { it.toDiagnostic() })
+        )
     }
 
     override fun didClose(params: DidCloseTextDocumentParams) {
@@ -27,9 +56,59 @@ class SamtTextDocumentService : TextDocumentService, LanguageClientAware {
         logger.info("Saved document ${params.textDocument.uri}")
     }
 
-    override fun diagnostic(params: DocumentDiagnosticParams): CompletableFuture<DocumentDiagnosticReport> = CompletableFuture.supplyAsync {
-        logger.info("Diagnostics for document ${params.textDocument.uri}")
-        DocumentDiagnosticReport(RelatedFullDocumentDiagnosticReport())
+    private fun SamtLocation.toRange(): Range {
+        return Range(
+            Position(start.row, start.col),
+            Position(start.row, end.col)
+        )
+    }
+
+    private fun DiagnosticMessage.toDiagnostic(): Diagnostic? {
+        val diagnostic = Diagnostic()
+        val primaryHighlight = this.highlights.firstOrNull()
+        if (primaryHighlight == null) {
+            logger.warning("Diagnostic message without location, how do I convert this???")
+            return null
+        }
+        // TODO consider highlightBeginningOnly
+        diagnostic.range = primaryHighlight.location.toRange()
+        diagnostic.severity = when (severity) {
+            SamtSeverity.Error -> DiagnosticSeverity.Error
+            SamtSeverity.Warning -> DiagnosticSeverity.Warning
+            SamtSeverity.Info -> DiagnosticSeverity.Information
+        }
+        diagnostic.source = "samt"
+        diagnostic.message = message
+        diagnostic.relatedInformation = highlights.filter { it.message != null }.map {
+            DiagnosticRelatedInformation(
+                Location("file://${it.location.source.absolutePath}", it.location.toRange()),
+                it.message
+            )
+        }
+        return diagnostic
+    }
+
+    private fun compile(uri: String, content: String): List<DiagnosticMessage> {
+        val source = SourceFile(uri, content)
+        val controller = DiagnosticController("todo")
+        val context = controller.createContext(source)
+
+        val tokenStream = Lexer.scan(source.content.reader(), context)
+
+        if (context.hasErrors()) {
+            return context.messages
+        }
+
+        val fileNode = try {
+            Parser.parse(source, tokenStream, context)
+        } catch (e: DiagnosticException) {
+            // error message is added to the diagnostic console, so it can be ignored here
+            return context.messages
+        }
+
+        SemanticModelBuilder.build(listOf(fileNode), controller)
+
+        return context.messages
     }
 
     override fun connect(client: LanguageClient) {