Move manual dictionary loading off the EDT

src/main/kotlin/com/intellij/plugin/applescript/lang/dictionary/project/AppleScriptProjectDictionaryService.kt

@@ -1,8 +1,10 @@
 package com.intellij.plugin.applescript.lang.dictionary.project
 
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Computable
 import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.plugin.applescript.lang.dictionary.discovery.ApplicationDiscoveryService
@@ -226,14 +228,25 @@ class AppleScriptProjectDictionaryService(
     fun createDictionaryFromFile(
         applicationName: String,
         applicationFile: VirtualFile,
-    ): ApplicationDictionary? {
+    ): ApplicationDictionary? = loadDictionaryInfo(applicationName, applicationFile)?.let(::createFromInfo)
+
+    internal fun loadDictionaryInfo(
+        applicationName: String,
+        applicationFile: VirtualFile,
+    ): DictionaryInfo? {
         val appIoFile = File(applicationFile.path)
         val info = fileProvider.createAndInitializeInfo(appIoFile, applicationName)
         if (info == null) {
             LOG.warn("Failed to get initialized dictionary info for $applicationName from $applicationFile")
-            return null
         }
-        return createFromInfo(info)
+        return info
+    }
+
+    @Synchronized
+    internal fun createFromLoadedInfo(info: DictionaryInfo): ApplicationDictionary? {
+        val application = ApplicationManager.getApplication()
+        application.assertIsDispatchThread()
+        return application.runReadAction(Computable { createFromInfo(info) })
     }
 
     fun getDictionary(applicationName: String): ApplicationDictionary? = dictionaryMap[applicationName]

src/main/kotlin/com/intellij/plugin/applescript/lang/ide/actions/LoadDictionaryAction.kt

@@ -1,20 +1,34 @@
 package com.intellij.plugin.applescript.lang.ide.actions
 
+import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer
 import com.intellij.ide.IdeView
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.actionSystem.LangDataKeys
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.fileChooser.FileChooser
 import com.intellij.openapi.fileChooser.FileChooserDescriptor
+import com.intellij.openapi.progress.ProcessCanceledException
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.Task
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.Messages
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.plugin.applescript.lang.dictionary.persistence.DictionaryInfo
 import com.intellij.plugin.applescript.lang.dictionary.project.AppleScriptProjectDictionaryService
 import com.intellij.plugin.applescript.lang.sdef.ApplicationDictionary
 import com.intellij.plugin.applescript.lang.sdef.extensionSupported
+import java.util.Queue
+import java.util.concurrent.CancellationException
+import java.util.concurrent.ConcurrentLinkedQueue
+
+private val LOG: Logger = Logger.getInstance("#${LoadDictionaryAction::class.java.name}")
+private const val LOAD_TASK_TITLE = "Loading AppleScript dictionaries"
 
 class LoadDictionaryAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
@@ -30,6 +44,34 @@ class LoadDictionaryAction : AnAction() {
     }
 }
 
+@Service(Service.Level.PROJECT)
+internal class DictionaryLoadQueue(
+    private val startTask: (Task.Backgroundable) -> Unit = { task -> task.queue() },
+) {
+    private val pendingTasks = ArrayDeque<Task.Backgroundable>()
+    private var isRunning = false
+
+    fun submit(createTask: (() -> Unit) -> Task.Backgroundable) {
+        ApplicationManager.getApplication().assertIsDispatchThread()
+        pendingTasks.addLast(createTask(::taskFinished))
+        if (!isRunning) startNext()
+    }
+
+    private fun taskFinished() {
+        ApplicationManager.getApplication().assertIsDispatchThread()
+        check(isRunning) { "Cannot finish a dictionary load when none is running" }
+        startNext()
+    }
+
+    private fun startNext() {
+        val nextTask =
+            generateSequence(pendingTasks::removeFirstOrNull)
+                .firstOrNull { task -> task.project?.isDisposed != true }
+        isRunning = nextTask != null
+        nextTask?.let(startTask)
+    }
+}
+
 private fun Project.projectDirectory(): VirtualFile? {
     val path = basePath
     return if (path == null) {
@@ -46,7 +88,7 @@ internal fun openLoadDirectoryDialog(
 ) {
     val singleApplicationName = appName?.takeUnless { StringUtil.isEmpty(it) }
     val descriptor =
-        createDictionaryFileChooserDescriptor(
+        createChooserDescriptor(
             chooseMultiple = singleApplicationName == null,
         )
 
@@ -55,7 +97,7 @@ internal fun openLoadDirectoryDialog(
     }
 }
 
-private fun createDictionaryFileChooserDescriptor(chooseMultiple: Boolean): FileChooserDescriptor =
+private fun createChooserDescriptor(chooseMultiple: Boolean): FileChooserDescriptor =
     FileChooserDescriptor(
         true,
         true,
@@ -65,34 +107,109 @@ private fun createDictionaryFileChooserDescriptor(chooseMultiple: Boolean): File
         chooseMultiple,
     )
 
-private fun loadSelectedDictionaries(
+internal class DictionaryLoadEffects(
+    val loadInfo: ((String, VirtualFile) -> DictionaryInfo?)? = null,
+    val restartDaemon: (() -> Unit)? = null,
+    val afterPublish: () -> Unit = {},
+)
+
+internal fun loadSelectedDictionaries(
     project: Project,
     files: List<VirtualFile>,
     singleApplicationName: String?,
+    effects: DictionaryLoadEffects = DictionaryLoadEffects(),
 ) {
-    val dictionaryService =
-        project.getService(AppleScriptProjectDictionaryService::class.java) ?: return
     val supportedFiles = files.filter { extensionSupported(it.extension) }
-
-    if (singleApplicationName != null) {
-        supportedFiles.firstOrNull()?.let { file ->
-            dictionaryService.createDictionaryFromFile(singleApplicationName, file)
-        }
-        return
-    }
-
     val dictionaryRequests =
-        supportedFiles.mapNotNull { file ->
-            resolveApplicationName(project, file)?.let { applicationName ->
-                applicationName to file
+        if (singleApplicationName != null) {
+            supportedFiles
+                .firstOrNull()
+                ?.let { file -> listOf(DictionaryLoadRequest(singleApplicationName, file)) }
+                .orEmpty()
+        } else {
+            supportedFiles.mapNotNull { file ->
+                resolveApplicationName(project, file)?.let { applicationName ->
+                    DictionaryLoadRequest(applicationName, file)
+                }
             }
         }
+    if (dictionaryRequests.isEmpty()) return
+
+    val dictionaryService = project.getService(AppleScriptProjectDictionaryService::class.java) ?: return
+    val loadQueue = project.getService(DictionaryLoadQueue::class.java) ?: return
+    val loadedInfos: Queue<DictionaryInfo> = ConcurrentLinkedQueue()
+    queueDictionaryLoads(
+        project = project,
+        loadQueue = loadQueue,
+        requests = dictionaryRequests,
+        loadInfo = { applicationName, file ->
+            (effects.loadInfo ?: dictionaryService::loadDictionaryInfo)(applicationName, file)?.let(loadedInfos::add)
+        },
+        publishDictionaries = {
+            if (!project.isDisposed) {
+                var hasCreatedDictionary = false
+                generateSequence(loadedInfos::poll).forEach { info ->
+                    if (dictionaryService.createFromLoadedInfo(info) != null) hasCreatedDictionary = true
+                }
+                if (hasCreatedDictionary) {
+                    effects.restartDaemon?.invoke()
+                        ?: DaemonCodeAnalyzer.getInstance(project).settingsChanged()
+                }
+            }
+            effects.afterPublish()
+        },
+    )
+}
+
+private fun queueDictionaryLoads(
+    project: Project,
+    loadQueue: DictionaryLoadQueue,
+    requests: List<DictionaryLoadRequest>,
+    loadInfo: (String, VirtualFile) -> Unit,
+    publishDictionaries: () -> Unit,
+) {
+    loadQueue.submit { taskFinished ->
+        object : Task.Backgroundable(project, LOAD_TASK_TITLE, true) {
+            override fun run(indicator: ProgressIndicator) {
+                requests.forEachIndexed { index, request ->
+                    indicator.checkCanceled()
+                    indicator.text = "Loading dictionary for ${request.applicationName}"
+                    try {
+                        loadInfo(request.applicationName, request.file)
+                    } catch (error: ProcessCanceledException) {
+                        throw error
+                    } catch (error: CancellationException) {
+                        throw ProcessCanceledException(error)
+                    } catch (error: RuntimeException) {
+                        throw IllegalStateException(
+                            "Failed to load dictionary '${request.applicationName}' from ${request.file.path}",
+                            error,
+                        )
+                    }
+                    indicator.fraction = (index + 1).toDouble() / requests.size
+                }
+            }
+
+            override fun onThrowable(error: Throwable) {
+                LOG.error("Failed to load selected AppleScript dictionaries", error)
+            }
 
-    dictionaryRequests.forEach { (applicationName, file) ->
-        dictionaryService.createDictionaryFromFile(applicationName, file)
+            override fun onFinished() {
+                try {
+                    publishDictionaries()
+                } finally {
+                    taskFinished()
+                }
+            }
+        }
     }
 }
 
+private data class DictionaryLoadRequest(
+    val applicationName: String,
+    val file: VirtualFile,
+)
+
 private fun resolveApplicationName(
     project: Project,
     file: VirtualFile,