backport: 22.0.1

CHANGELOG.md

@@ -17,6 +17,16 @@ Changelog structure reference:
 
 ## [Unreleased]
 
+## [22.0.1]
+
+### Fixed
+
+- LSP
+  - Changing ZLS configs would not restart ZLS
+
+- Project
+  - Occasional "AWT events are not allowed inside write action" error coming from LSP
+
 ## [22.0.0]
 
 ### Added

gradle.properties

@@ -1,7 +1,7 @@
 pluginName=ZigBrains
 pluginRepositoryUrl=https://github.com/FalsePattern/ZigBrains
 
-pluginVersion=22.0.0
+pluginVersion=22.0.1
 
 pluginSinceBuild=241
 pluginUntilBuild=241.*

lsp/src/main/kotlin/com/falsepattern/zigbrains/lsp/ZLSStartup.kt

@@ -55,6 +55,9 @@ class ZLSStartup: ProjectActivity {
                     EditorNotifications.getInstance(project).updateAllNotifications()
                 }
                 currentState = running
+                if (handleStartLSP(project)) {
+                    EditorNotifications.getInstance(project).updateAllNotifications()
+                }
                 delay(1000)
             }
         }

lsp/src/main/kotlin/com/falsepattern/zigbrains/lsp/ZigLanguageServerFactory.kt

@@ -39,8 +39,11 @@ import com.redhat.devtools.lsp4ij.client.features.LSPClientFeatures
 import com.redhat.devtools.lsp4ij.client.features.LSPFormattingFeature
 import com.redhat.devtools.lsp4ij.client.features.LSPInlayHintFeature
 import com.redhat.devtools.lsp4ij.server.StreamConnectionProvider
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 class ZigLanguageServerFactory: LanguageServerFactory, LanguageServerEnablementSupport {
     override fun createConnectionProvider(project: Project): StreamConnectionProvider {
@@ -93,35 +96,67 @@ fun Project.zlsEnabled(value: Boolean) {
 suspend fun Project.zlsRunningAsync(): Boolean {
     if (!zlsEnabledAsync())
         return false
-    return zlsRunningLsp4ij()
+    return lsm.isRunning
 }
 
 fun Project.zlsRunningSync(): Boolean {
     if (!zlsEnabledSync())
         return false
-    return zlsRunningLsp4ij()
+    return lsm.isRunning
 }
 
-private fun Project.zlsRunningLsp4ij(): Boolean {
+private val Project.lsm get() = service<LanguageServerManager>()
-    val manager = service<LanguageServerManager>()
+
-    val status = manager.getServerStatus("ZigBrains")
+private val LanguageServerManager.isRunning get(): Boolean {
+    val status = getServerStatus("ZigBrains")
     return status == ServerStatus.started || status == ServerStatus.starting
 }
 
+private val START_MUTEX = Mutex()
+
 class ZLSStarter: LanguageServerStarter {
     override fun startLSP(project: Project, restart: Boolean) {
         project.zigCoroutineScope.launch {
-            val manager = project.service<LanguageServerManager>()
+            START_MUTEX.withLock {
-            val status = manager.getServerStatus("ZigBrains")
+                if (restart) {
-            if ((status == ServerStatus.started || status == ServerStatus.starting) && !restart)
+                    project.putUserData(RESTART_KEY, Unit)
-                return@launch
+                } else {
-            manager.stop("ZigBrains")
+                    project.putUserData(START_KEY, Unit)
-            if (project.zlsSettings.validateAsync()) {
+                }
-                manager.start("ZigBrains")
             }
         }
     }
-
 }
 
-private val ENABLED_KEY = Key.create<Boolean>("ZLS_ENABLED")
+private suspend fun doStart(project: Project, restart: Boolean) {
+    if (!restart && project.lsm.isRunning)
+        return
+    while (!project.isDisposed && project.lsm.isRunning) {
+        project.lsm.stop("ZigBrains")
+        delay(250)
+    }
+    if (project.zlsSettings.validateAsync()) {
+        delay(250)
+        project.lsm.start("ZigBrains")
+    }
+}
+
+suspend fun handleStartLSP(project: Project) = START_MUTEX.withLock {
+    if (project.getUserData(RESTART_KEY) != null) {
+        project.putUserData(RESTART_KEY, null)
+        project.putUserData(START_KEY, null)
+        doStart(project, true)
+        true
+    } else if (project.getUserData(START_KEY) != null) {
+        project.putUserData(START_KEY, null)
+        doStart(project, false)
+        true
+    } else {
+        false
+    }
+}
+
+private val ENABLED_KEY = Key.create<Boolean>("ZLS_ENABLED")
+
+private val RESTART_KEY = Key.create<Unit>("ZLS_RESTART_REQUEST")
+private val START_KEY = Key.create<Unit>("ZLS_START_REQUEST")

lsp/src/main/kotlin/com/falsepattern/zigbrains/lsp/settings/ZLSProjectSettingsService.kt

@@ -82,7 +82,7 @@ class ZLSProjectSettingsService(val project: Project): PersistentStateComponent<
         }
     }
 
-    fun validateSync() = if (application.isDispatchThread) {
+    fun validateSync() = if (application.isDispatchThread && !application.isWriteAccessAllowed) {
         runWithModalProgressBlocking(ModalTaskOwner.project(project), ZLSBundle.message("progress.title.validate")) {
             validateAsync()
         }

lsp/src/main/kotlin/com/falsepattern/zigbrains/lsp/settings/ZLSSettingsConfigurable.kt

@@ -22,7 +22,6 @@
 
 package com.falsepattern.zigbrains.lsp.settings
 
-import com.falsepattern.zigbrains.lsp.startLSP
 import com.falsepattern.zigbrains.shared.SubConfigurable
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer

lsp/src/main/resources/META-INF/zigbrains-lsp.xml

@@ -88,10 +88,10 @@
         />
     </extensions>
 
-    <applicationListeners>
+    <projectListeners>
         <listener
                 class="com.falsepattern.zigbrains.lsp.ZLSStarter"
                 topic="com.falsepattern.zigbrains.lsp.LanguageServerStarter"
         />
-    </applicationListeners>
+    </projectListeners>
 </idea-plugin>