fix: remove janky suspending lazy logic

CHANGELOG.md

@@ -17,6 +17,11 @@ Changelog structure reference:
 
 ## [Unreleased]
 
+### Fixed
+
+- Project
+  - IDE freezes when opening a zig project / doing zig init
+
 ## [20.0.0]
 
 ### Added

core/src/main/kotlin/com/falsepattern/zigbrains/project/toolchain/stdlib/ZigSyntheticLibrary.kt

@@ -25,25 +25,22 @@ package com.falsepattern.zigbrains.project.toolchain.stdlib
 import com.falsepattern.zigbrains.Icons
 import com.falsepattern.zigbrains.project.settings.ZigProjectSettings
 import com.falsepattern.zigbrains.project.settings.zigProjectSettings
-import com.falsepattern.zigbrains.shared.coroutine.getOrAwaitModalOrBlocking
-import com.falsepattern.zigbrains.shared.zigCoroutineScope
 import com.intellij.navigation.ItemPresentation
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.SyntheticLibrary
 import com.intellij.openapi.util.io.toNioPathOrNull
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.refreshAndFindVirtualDirectory
-import com.intellij.platform.ide.progress.ModalTaskOwner
+import kotlinx.coroutines.runBlocking
-import com.intellij.util.suspendingLazy
 import java.util.*
 import javax.swing.Icon
 
 class ZigSyntheticLibrary(val project: Project) : SyntheticLibrary(), ItemPresentation {
-    private val roots = project.zigCoroutineScope.suspendingLazy {
+    private val roots by lazy {
         getRoots(project.zigProjectSettings.state, project)
     }
 
-    private val name = project.zigCoroutineScope.suspendingLazy {
+    private val name by lazy {
         getName(project.zigProjectSettings.state, project)
     }
 
@@ -59,7 +56,7 @@ class ZigSyntheticLibrary(val project: Project) : SyntheticLibrary(), ItemPresen
     }
 
     override fun getPresentableText(): String {
-        return name.getOrAwaitModalOrBlocking({ModalTaskOwner.project(project)}, {"ZigSyntheticLibrary.getPresentableText"})
+        return name
     }
 
     override fun getIcon(unused: Boolean): Icon {
@@ -67,28 +64,28 @@ class ZigSyntheticLibrary(val project: Project) : SyntheticLibrary(), ItemPresen
     }
 
     override fun getSourceRoots(): Collection<VirtualFile> {
-        return roots.getOrAwaitModalOrBlocking({ ModalTaskOwner.project(project)}, {"ZigSyntheticLibrary.getSourceRoots"})
+        return roots
     }
 
 }
 
 
 
-private suspend fun getName(
+private fun getName(
     state: ZigProjectSettings,
     project: Project
 ): String {
     val tc = state.toolchain ?: return "Zig"
-    val version = tc.zig.getEnv(project).version
+    val version = runBlocking { tc.zig.getEnv(project).version }
     return "Zig $version"
 }
 
-private suspend fun getRoots(
+private fun getRoots(
     state: ZigProjectSettings,
     project: Project
 ): Set<VirtualFile> {
     val toolchain = state.toolchain
-    run {
+    if (state.overrideStdPath) run {
         val ePathStr = state.explicitPathToStd ?: return@run
         val ePath = ePathStr.toNioPathOrNull() ?: return@run
         if (ePath.isAbsolute) {
@@ -103,7 +100,7 @@ private suspend fun getRoots(
         }
     }
     if (toolchain != null) {
-        val stdPath = toolchain.zig.getEnv(project).stdPath(toolchain, project) ?: return emptySet()
+        val stdPath = runBlocking { toolchain.zig.getEnv(project) }.stdPath(toolchain, project) ?: return emptySet()
         val roots = stdPath.refreshAndFindVirtualDirectory() ?: return emptySet()
         return setOf(roots)
     }

core/src/main/kotlin/com/falsepattern/zigbrains/shared/coroutine/CoroutinesUtil.kt

@@ -28,7 +28,6 @@ import com.intellij.openapi.application.asContextElement
 import com.intellij.platform.ide.progress.ModalTaskOwner
 import com.intellij.platform.ide.progress.TaskCancellation
 import com.intellij.platform.ide.progress.runWithModalProgressBlocking
-import com.intellij.util.SuspendingLazy
 import com.intellij.util.application
 import kotlinx.coroutines.*
 
@@ -40,16 +39,6 @@ inline fun <T> runModalOrBlocking(taskOwnerFactory: () -> ModalTaskOwner, titleF
     }
 }
 
-inline fun <T> SuspendingLazy<T>.getOrAwaitModalOrBlocking(taskOwnerFactory: () -> ModalTaskOwner, titleFactory: () -> String, cancellationFactory: () -> TaskCancellation = {TaskCancellation.cancellable()}): T {
-    if (isInitialized()) {
-        return getInitialized()
-    } else {
-        return runModalOrBlocking(taskOwnerFactory, titleFactory, cancellationFactory) {
-            getValue()
-        }
-    }
-}
-
 suspend inline fun <T> withEDTContext(state: ModalityState = ModalityState.defaultModalityState(), noinline block: suspend CoroutineScope.() -> T): T {
     return withContext(Dispatchers.EDT + state.asContextElement(), block = block)
 }