Language Server File Operations

cli/src/test/kotlin/tools/samt/cli/ASTPrinterTest.kt

@@ -31,11 +31,19 @@ class ASTPrinterTest {
             @Description("This is a service")
             service MyService {
               testmethod(foo: A): B
+              oneway testmethod2(foo: A)
             }
 
             provide MyEndpoint {
               implements MyService
-              transport HTTP
+              transport HTTP {
+                operations: {
+                    MyService: {
+                        testmethod: "POST /testmethod",
+                        testmethod2: "POST /testmethod2"
+                    }
+                }
+              }
             }
 
             consume MyEndpoint {
@@ -105,22 +113,41 @@ class ASTPrinterTest {
             │ │ │   └─IdentifierNode A <17:19>
             │ │ └─BundleIdentifierNode B <17:23>
             │ │   └─IdentifierNode B <17:23>
+            │ ├─OnewayOperationNode <18:3>
+            │ │ ├─IdentifierNode testmethod2 <18:10>
+            │ │ └─OperationParameterNode <18:22>
+            │ │   ├─IdentifierNode foo <18:22>
+            │ │   └─BundleIdentifierNode A <18:27>
+            │ │     └─IdentifierNode A <18:27>
             │ └─AnnotationNode <15:1>
             │   ├─IdentifierNode Description <15:2>
             │   └─StringNode "This is a service" <15:14>
-            ├─ProviderDeclarationNode <20:1>
-            │ ├─IdentifierNode MyEndpoint <20:9>
-            │ ├─ProviderImplementsNode <21:3>
-            │ │ └─BundleIdentifierNode MyService <21:14>
-            │ │   └─IdentifierNode MyService <21:14>
-            │ └─ProviderTransportNode <22:3>
-            │   └─IdentifierNode HTTP <22:13>
-            └─ConsumerDeclarationNode <25:1>
-              ├─BundleIdentifierNode MyEndpoint <25:9>
-              │ └─IdentifierNode MyEndpoint <25:9>
-              └─ConsumerUsesNode <26:3>
-                └─BundleIdentifierNode MyService <26:8>
-                  └─IdentifierNode MyService <26:8>
+            ├─ProviderDeclarationNode <21:1>
+            │ ├─IdentifierNode MyEndpoint <21:9>
+            │ ├─ProviderImplementsNode <22:3>
+            │ │ └─BundleIdentifierNode MyService <22:14>
+            │ │   └─IdentifierNode MyService <22:14>
+            │ └─ProviderTransportNode <23:3>
+            │   ├─IdentifierNode HTTP <23:13>
+            │   └─ObjectNode <23:18>
+            │     └─ObjectFieldNode <24:5>
+            │       ├─IdentifierNode operations <24:5>
+            │       └─ObjectNode <24:17>
+            │         └─ObjectFieldNode <25:9>
+            │           ├─IdentifierNode MyService <25:9>
+            │           └─ObjectNode <25:20>
+            │             ├─ObjectFieldNode <26:13>
+            │             │ ├─IdentifierNode testmethod <26:13>
+            │             │ └─StringNode "POST /testmethod" <26:25>
+            │             └─ObjectFieldNode <27:13>
+            │               ├─IdentifierNode testmethod2 <27:13>
+            │               └─StringNode "POST /testmethod2" <27:26>
+            └─ConsumerDeclarationNode <33:1>
+              ├─BundleIdentifierNode MyEndpoint <33:9>
+              │ └─IdentifierNode MyEndpoint <33:9>
+              └─ConsumerUsesNode <34:3>
+                └─BundleIdentifierNode MyService <34:8>
+                  └─IdentifierNode MyService <34:8>
         """.trimIndent().trim(), dumpWithoutColorCodes.trimIndent().trim())
     }
 

cli/src/test/kotlin/tools/samt/cli/TypePrinterTest.kt

@@ -13,7 +13,7 @@ import kotlin.test.assertFalse
 
 class TypePrinterTest {
     @Test
-    fun `correctly formats an AST dump`() {
+    fun `correctly formats a type dump`() {
         val stuffPackage = parse("""
             package test.stuff
 
@@ -33,6 +33,8 @@ class TypePrinterTest {
               implements MyService
               transport HTTP
             }
+
+            typealias F = E
         """.trimIndent())
         val consumerPackage = parse("""
             package test.other.company
@@ -57,6 +59,7 @@ class TypePrinterTest {
               ├─stuff
               │  enum E
               │  record A
+              │  typealias F = E
               │  service MyService
               │  provider MyEndpoint
               └─other

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

@@ -7,18 +7,28 @@ import tools.samt.lexer.Lexer
 import tools.samt.lexer.Token
 import tools.samt.parser.FileNode
 import tools.samt.parser.Parser
+import java.net.URI
+import kotlin.io.path.readText
+import kotlin.io.path.toPath
 
 class FileInfo(
-    val diagnosticContext: DiagnosticContext,
-    val sourceFile: SourceFile,
-    @Suppress("unused") val tokens: List<Token>,
-    val fileNode: FileNode? = null,
+        val diagnosticContext: DiagnosticContext,
+        val sourceFile: SourceFile,
+        val tokens: List<Token> = emptyList(),
+        val fileNode: FileNode? = null,
 )
 
+val FileInfo.path get() = sourceFile.path
+val FileInfo.content get() = sourceFile.content
+
 fun parseFile(sourceFile: SourceFile): FileInfo {
     val diagnosticContext = DiagnosticContext(sourceFile)
 
-    val tokens = Lexer.scan(sourceFile.content.reader(), diagnosticContext).toList()
+    val tokens = try {
+        Lexer.scan(sourceFile.content.reader(), diagnosticContext).toList()
+    } catch (e: DiagnosticException) {
+        return FileInfo(diagnosticContext, sourceFile)
+    }
 
     if (diagnosticContext.hasErrors()) {
         return FileInfo(diagnosticContext, sourceFile, tokens)
@@ -33,3 +43,8 @@ fun parseFile(sourceFile: SourceFile): FileInfo {
 
     return FileInfo(diagnosticContext, sourceFile, tokens, fileNode)
 }
+
+fun readAndParseFile(uri: URI): FileInfo {
+    val sourceFile = SourceFile(uri, uri.toPath().readText())
+    return parseFile(sourceFile)
+}

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

@@ -9,11 +9,7 @@ fun DiagnosticMessage.toDiagnostic(): Diagnostic? {
     val diagnostic = Diagnostic()
     val primaryHighlight = this.highlights.firstOrNull() ?: return null
     diagnostic.range = primaryHighlight.location.toRange()
-    diagnostic.severity = when (severity) {
-        DiagnosticSeverity.Error -> org.eclipse.lsp4j.DiagnosticSeverity.Error
-        DiagnosticSeverity.Warning -> org.eclipse.lsp4j.DiagnosticSeverity.Warning
-        DiagnosticSeverity.Info -> org.eclipse.lsp4j.DiagnosticSeverity.Information
-    }
+    diagnostic.severity = severity.toLspSeverity()
     diagnostic.source = "samt"
     diagnostic.message = message
     diagnostic.relatedInformation = highlights.filter { it.message != null }.map {
@@ -25,9 +21,13 @@ fun DiagnosticMessage.toDiagnostic(): Diagnostic? {
     return diagnostic
 }
 
-fun SamtLocation.toRange(): Range {
-    return Range(
-        Position(start.row, start.col),
-        Position(end.row, end.col)
-    )
+fun DiagnosticSeverity.toLspSeverity(): org.eclipse.lsp4j.DiagnosticSeverity = when (this) {
+    DiagnosticSeverity.Error -> org.eclipse.lsp4j.DiagnosticSeverity.Error
+    DiagnosticSeverity.Warning -> org.eclipse.lsp4j.DiagnosticSeverity.Warning
+    DiagnosticSeverity.Info -> org.eclipse.lsp4j.DiagnosticSeverity.Information
 }
+
+fun SamtLocation.toRange(): Range = Range(
+    Position(start.row, start.col),
+    Position(end.row, end.col)
+)

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

@@ -0,0 +1,61 @@
+package tools.samt.ls
+
+import tools.samt.common.DiagnosticController
+import tools.samt.common.DiagnosticMessage
+import tools.samt.common.collectSamtFiles
+import tools.samt.common.readSamtSource
+import tools.samt.semantic.Package
+import tools.samt.semantic.SemanticModelBuilder
+import java.net.URI
+
+class SamtFolder(val path: URI) : Iterable<FileInfo> {
+    private val files = mutableMapOf<URI, FileInfo>()
+    var globalPackage: Package? = null
+        private set
+    private var semanticController: DiagnosticController = DiagnosticController(path)
+
+    fun set(fileInfo: FileInfo) {
+        files[fileInfo.sourceFile.path] = fileInfo
+    }
+
+    fun remove(fileUri: URI) {
+        files.remove(fileUri)
+    }
+
+    operator fun get(path: URI): FileInfo? = files[path]
+
+    override fun iterator(): Iterator<FileInfo> = files.values.iterator()
+
+    operator fun contains(path: URI) = path in files
+
+    fun getFilesIn(directoryPath: URI): List<URI> {
+        return files.keys.filter { it.startsWith(directoryPath) }
+    }
+
+    fun buildSemanticModel() {
+        semanticController = DiagnosticController(path)
+        globalPackage = SemanticModelBuilder.build(mapNotNull { it.fileNode }, semanticController)
+    }
+
+    private fun getMessages(path: URI): List<DiagnosticMessage> {
+        val fileInfo = files[path] ?: return emptyList()
+        return fileInfo.diagnosticContext.messages +
+                semanticController.getOrCreateContext(fileInfo.sourceFile).messages
+    }
+
+    fun getAllMessages() = files.keys.associateWith {
+        getMessages(it)
+    }
+
+    companion object {
+        fun fromDirectory(path: URI): SamtFolder {
+            val controller = DiagnosticController(path)
+            val workspace = SamtFolder(path)
+            val sourceFiles = collectSamtFiles(path).readSamtSource(controller)
+            sourceFiles.forEach {
+                workspace.set(parseFile(it))
+            }
+            return workspace
+        }
+    }
+}

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

@@ -3,20 +3,18 @@ package tools.samt.ls
 import org.eclipse.lsp4j.*
 import org.eclipse.lsp4j.jsonrpc.messages.Either
 import org.eclipse.lsp4j.services.*
-import tools.samt.common.DiagnosticController
-import tools.samt.common.collectSamtFiles
-import tools.samt.common.readSamtSource
 import java.io.Closeable
-import java.net.URI
+import java.util.*
 import java.util.concurrent.CompletableFuture
 import java.util.logging.Logger
 import kotlin.system.exitProcess
 
 class SamtLanguageServer : LanguageServer, LanguageClientAware, Closeable {
     private lateinit var client: LanguageClient
     private val logger = Logger.getLogger("SamtLanguageServer")
-    private val workspaces = mutableMapOf<URI, SamtWorkspace>()
-    private val textDocumentService = SamtTextDocumentService(workspaces)
+    private val workspace = SamtWorkspace()
+    private val textDocumentService = SamtTextDocumentService(workspace)
+    private val workspaceService = SamtWorkspaceService(workspace)
 
     override fun initialize(params: InitializeParams): CompletableFuture<InitializeResult> =
         CompletableFuture.supplyAsync {
@@ -28,14 +26,44 @@ class SamtLanguageServer : LanguageServer, LanguageClientAware, Closeable {
                     range = Either.forLeft(false)
                     full = Either.forLeft(true)
                 }
+                workspace = WorkspaceServerCapabilities().apply {
+                    workspaceFolders = WorkspaceFoldersOptions().apply {
+                        supported = true
+                        changeNotifications = Either.forRight(true)
+                    }
+                    fileOperations = FileOperationsServerCapabilities().apply {
+                        val samtFilter = FileOperationFilter().apply {
+                            pattern = FileOperationPattern().apply {
+                                glob = "**/*.samt"
+                                matches = FileOperationPatternKind.File
+                            }
+                        }
+                        val folderFilter = FileOperationFilter().apply {
+                            pattern = FileOperationPattern().apply {
+                                glob = "**"
+                                matches = FileOperationPatternKind.Folder
+                            }
+                        }
+                        didCreate = FileOperationOptions().apply {
+                            filters = listOf(samtFilter)
+                        }
+                        FileOperationOptions().apply {
+                            filters = listOf(samtFilter, folderFilter)
+                        }.let {
+                            didRename = it
+                            didDelete = it
+                        }
+                    }
+                }
                 definitionProvider = Either.forLeft(true)
                 referencesProvider = Either.forLeft(true)
             }
             InitializeResult(capabilities)
         }
 
     override fun initialized(params: InitializedParams) {
-        pushDiagnostics()
+        registerFileWatchCapability()
+        client.updateWorkspace(workspace)
     }
 
     override fun shutdown(): CompletableFuture<Any> = CompletableFuture.completedFuture(null)
@@ -46,11 +74,12 @@ class SamtLanguageServer : LanguageServer, LanguageClientAware, Closeable {
 
     override fun getTextDocumentService(): TextDocumentService = textDocumentService
 
-    override fun getWorkspaceService(): WorkspaceService? = null
+    override fun getWorkspaceService(): WorkspaceService = workspaceService
 
     override fun connect(client: LanguageClient) {
         this.client = client
         textDocumentService.connect(client)
+        workspaceService.connect(client)
         logger.info("Connected to client")
     }
 
@@ -59,31 +88,26 @@ class SamtLanguageServer : LanguageServer, LanguageClientAware, Closeable {
     }
 
     private fun buildSamtModel(params: InitializeParams) {
-        val folders = params.workspaceFolders.map { it.uri.toPathUri() }
+        val folders = params.workspaceFolders?.map { it.uri.toPathUri() }.orEmpty()
         for (folder in folders) {
-            // if the folder is contained within another folder ignore it
-            if (folders.any { folder != it && folder.path.startsWith(it.path) }) continue
-            workspaces[folder] = buildWorkspace(folder)
+            workspace.addFolder(SamtFolder.fromDirectory(folder))
         }
     }
 
-    private fun buildWorkspace(workspacePath: URI): SamtWorkspace {
-        val diagnosticController = DiagnosticController(workspacePath)
-        val sourceFiles = collectSamtFiles(workspacePath).readSamtSource(diagnosticController)
-        val workspace = SamtWorkspace(diagnosticController)
-        sourceFiles.asSequence().map(::parseFile).forEach(workspace::add)
-        workspace.buildSemanticModel()
-        return workspace
-    }
-
-    private fun pushDiagnostics() {
-        workspaces.values.flatMap { workspace ->
-            workspace.getAllMessages().map { (path, messages) ->
-                PublishDiagnosticsParams(
-                    path.toString(),
-                    messages.map { it.toDiagnostic() }
+    private fun registerFileWatchCapability() {
+        val capability = "workspace/didChangeWatchedFiles"
+        client.registerCapability(RegistrationParams(listOf(
+            Registration(UUID.randomUUID().toString(), capability, DidChangeWatchedFilesRegistrationOptions().apply {
+                watchers = listOf(
+                    FileSystemWatcher().apply {
+                        globPattern = Either.forLeft("**/*.samt")
+                    },
+                    FileSystemWatcher().apply {
+                        globPattern = Either.forLeft("**/")
+                        kind = WatchKind.Create or WatchKind.Delete
+                    },
                 )
-            }
-        }.forEach(client::publishDiagnostics)
+            })
+        )))
     }
 }