Add a bunch of ProgressManager.checkCanceled() checks. Should hopefully fix UI freeze. #114

Author: ekvedaras

CHANGELOG.md

@@ -4,8 +4,11 @@
 
 ## [Unreleased]
 
+### Fixed
+- Add a bunch of `ProgressManager.checkCanceled()` checks. Should hopefully fix UI freeze. #114
+
 ## [4.0.3]
-### Fixed
+### Fixed
 - Use non-blocking read action. Should hopefully fix UI freeze. #114
 
 ## [4.0.2]
@@ -188,4 +191,4 @@
     - Table alias support
     - Model table name resolving
     - Relation table name resolving
-- Initial scaffold created from [IntelliJ Platform Plugin Template](https://github.com/JetBrains/intellij-platform-plugin-template)
+- Initial scaffold created from [IntelliJ Platform Plugin Template](https://github.com/JetBrains/intellij-platform-plugin-template)

gradle.properties

@@ -4,7 +4,7 @@
 pluginGroup = dev.ekvedaras.laravelquery
 pluginName = Laravel Query
 # SemVer format -> https://semver.org
-pluginVersion=4.0.3
+pluginVersion=4.0.4
 
 # See https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 # for insight into build numbers and IntelliJ Platform versions.

src/main/kotlin/dev/ekvedaras/laravelquery/models/DbReferenceExpression.kt

@@ -9,6 +9,7 @@ import com.intellij.database.model.DasTableKey
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.ReadAction
+import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.project.DumbService
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
@@ -70,8 +71,12 @@ class DbReferenceExpression(val expression: PsiElement, val type: Type) {
                 }
             }, expressionDisposable)
             ReadAction.nonBlocking<Unit> {
-                TableAndAliasCollector(this).collect()
-                DbReferenceResolver(this).resolve()
+                try {
+                    TableAndAliasCollector(this).collect()
+                    DbReferenceResolver(this).resolve()
+                } catch (_: ProcessCanceledException) {
+
+                }
             }.inSmartMode(project).expireWith(expressionDisposable).executeSynchronously()
         }
     }

src/main/kotlin/dev/ekvedaras/laravelquery/utils/DbReferenceResolver.kt

@@ -6,6 +6,7 @@ import com.intellij.database.model.DasIndex
 import com.intellij.database.model.DasNamespace
 import com.intellij.database.model.DasTable
 import com.intellij.database.model.DasTableKey
+import com.intellij.openapi.progress.ProgressManager
 import dev.ekvedaras.laravelquery.models.DbReferenceExpression
 import dev.ekvedaras.laravelquery.utils.DatabaseUtils.Companion.columnsInParallel
 import dev.ekvedaras.laravelquery.utils.DatabaseUtils.Companion.dbDataSourcesInParallel
@@ -49,6 +50,8 @@ private class ResolverForTableMethods(
     fun resolve() {
         resolveSchemes()
 
+        ProgressManager.checkCanceled()
+
         when (reference.parts.size) {
             1 -> resolveTables()
             else -> resolveSchemaTables()
@@ -72,7 +75,11 @@ private class ResolverForTableMethods(
      */
     private fun resolveTables() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.tablesInParallel().forEach { table ->
+                ProgressManager.checkCanceled()
+
                 if (table.nameWithoutPrefix(reference.project) == reference.parts.last()) {
                     tables.add(table)
                 } else if (reference.tablesAndAliases[reference.parts.last()]?.first == table.nameWithoutPrefix(reference.project)) {
@@ -88,9 +95,13 @@ private class ResolverForTableMethods(
      */
     private fun resolveSchemaTables() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.schemasInParallel()
                 .filter { schemas.contains(it) }
                 .forEach { schema ->
+                    ProgressManager.checkCanceled()
+
                     dataSource.tablesInParallel()
                         .filter { it.dasParent?.name == schema.name }
                         .filter { it.nameWithoutPrefix(reference.project) == reference.parts.last() }
@@ -122,11 +133,15 @@ private class ResolverForColumnMethods(
      */
     private fun withOnePart() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.schemasInParallel()
                 .filter { it.name == reference.parts.first() }
                 .forEach { schemas.add(it) }
 
             dataSource.tablesInParallel().forEach { dasTable ->
+                ProgressManager.checkCanceled()
+
                 if (dasTable.nameWithoutPrefix(reference.project) == reference.parts.first()) {
                     tables.add(dasTable)
                 } else if (reference.tablesAndAliases[reference.parts.first()]?.first == dasTable.nameWithoutPrefix(reference.project)) {
@@ -147,11 +162,15 @@ private class ResolverForColumnMethods(
      */
     private fun withTwoParts() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.schemasInParallel()
                 .filter { it.name == reference.parts.first() }
                 .forEach { schemas.add(it) }
 
             dataSource.tablesInParallel().forEach { table ->
+                ProgressManager.checkCanceled()
+
                 if (schemas.isEmpty() || schemas.contains(table.dasParent)) {
                     addTablesAndTheirColumns(table)
                 }
@@ -185,10 +204,14 @@ private class ResolverForColumnMethods(
      */
     private fun withThreeParts() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.schemasInParallel()
                 .filter { it.name == reference.parts.first() }
                 .forEach { schemas.add(it) }
 
+            ProgressManager.checkCanceled()
+
             dataSource.tablesInParallel()
                 .filter { schemas.contains(it.dasParent) }
                 .forEach { addTableAndItsColumns(it) }
@@ -218,11 +241,15 @@ private class ResolverForIndexMethods(
 ) {
     fun resolve() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.tablesInParallel().filter {
                 reference.tablesAndAliases.containsKey(it.nameWithoutPrefix(reference.project))
             }.filter {
                 (reference.tablesAndAliases[it.nameWithoutPrefix(reference.project)]?.second ?: it.dasParent?.name) == it.dasParent?.name
             }.forEach { table ->
+                ProgressManager.checkCanceled()
+
                 table.indexesInParallel()
                     .filter { it.name == reference.parts[0] }
                     .forEach { indexes.add(it) }
@@ -237,11 +264,15 @@ private class ResolverForKeyMethods(
 ) {
     fun resolve() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.tablesInParallel().filter {
                 reference.tablesAndAliases.containsKey(it.nameWithoutPrefix(reference.project))
             }.filter {
                 (reference.tablesAndAliases[it.nameWithoutPrefix(reference.project)]?.second ?: it.dasParent?.name) == it.dasParent?.name
             }.forEach { table ->
+                ProgressManager.checkCanceled()
+
                 table.keysInParallel()
                     .filter { it.name == reference.parts[0] }
                     .forEach { keys.add(it) }
@@ -256,11 +287,15 @@ private class ResolverForForeignKeyMethods(
 ) {
     fun resolve() {
         reference.project.dbDataSourcesInParallel().forEach { dataSource ->
+            ProgressManager.checkCanceled()
+
             dataSource.tablesInParallel().filter {
                 reference.tablesAndAliases.containsKey(it.nameWithoutPrefix(reference.project))
             }.filter {
                 (reference.tablesAndAliases[it.nameWithoutPrefix(reference.project)]?.second ?: it.dasParent?.name) == it.dasParent?.name
             }.forEach { table ->
+                ProgressManager.checkCanceled()
+
                 table.foreignKeysInParallel()
                     .filter { it.name == reference.parts[0] }
                     .forEach { foreignKeys.add(it) }

src/main/kotlin/dev/ekvedaras/laravelquery/utils/ModelRelationResolver.kt

@@ -1,5 +1,6 @@
 package dev.ekvedaras.laravelquery.utils
 
+import com.intellij.openapi.progress.ProgressManager
 import com.intellij.psi.PsiElement
 import com.jetbrains.php.lang.psi.elements.MethodReference
 import com.jetbrains.php.lang.psi.elements.PhpClass
@@ -28,13 +29,20 @@ class ModelRelationResolver(
                 it.isChildOf(LaravelClasses.Relation)
             }
         }
+
+        ProgressManager.checkCanceled()
+
         if (relationMethod != null && relationMethod.name != null) {
             resolveRelationTable(relationMethod.name ?: "", model)
             return
         }
 
+        ProgressManager.checkCanceled()
+
         tableAndAliasCollector.resolveTableName(model)
 
+        ProgressManager.checkCanceled()
+
         val deepParent =
             method.parent?.parent?.parent?.parent?.parent?.parent // TODO utilize parentOfType<>() ?
         if (deepParent?.isInsideRelationClosure() == true) {
@@ -67,6 +75,8 @@ class ModelRelationResolver(
             ) as? ParameterListImpl
             )?.getParameter(0) ?: return
 
+        ProgressManager.checkCanceled()
+
         when (firstParam) {
             is ClassConstantReferenceImpl -> {
                 tableAndAliasCollector.resolveTableName(

src/main/kotlin/dev/ekvedaras/laravelquery/utils/TableAndAliasCollector.kt

@@ -1,5 +1,6 @@
 package dev.ekvedaras.laravelquery.utils
 
+import com.intellij.openapi.progress.ProgressManager
 import com.intellij.psi.PsiReference
 import com.intellij.psi.util.parentOfType
 import com.jetbrains.php.lang.psi.elements.MethodReference
@@ -35,15 +36,25 @@ class TableAndAliasCollector(private val reference: DbReferenceExpression) {
         val method = MethodUtils.resolveMethodReference(reference.expression) ?: return
         val methods = Collections.synchronizedList(mutableListOf<MethodReference>())
 
+        ProgressManager.checkCanceled()
+
         collectMethodsAcrossVariableReferences(methods, method)
         collectMethodsInCurrentTree(methods, method)
 
+        ProgressManager.checkCanceled()
+
         relationResolver.resolveModelAndRelationTables(methods, method)
+
+        ProgressManager.checkCanceled()
+
         schemaTableResolver.resolve(methods, method)
 
         methods
             .filter { LaravelUtils.BuilderTableMethods.contains(it.name) }
-            .forEach { scanMethodReference(it) }
+            .forEach {
+                ProgressManager.checkCanceled()
+                scanMethodReference(it)
+            }
     }
 
     private fun collectMethodsAcrossVariableReferences(methods: MutableList<MethodReference>, method: MethodReference) {
@@ -55,7 +66,10 @@ class TableAndAliasCollector(private val reference: DbReferenceExpression) {
             collectMethodsInVariableReference(declaration.reference as PsiReference, methods)
         }
 
+        ProgressManager.checkCanceled()
+
         variable.references.forEach {
+            ProgressManager.checkCanceled()
             collectMethodsInVariableReference(it, methods)
         }
     }
@@ -72,6 +86,8 @@ class TableAndAliasCollector(private val reference: DbReferenceExpression) {
             return
         }
 
+        ProgressManager.checkCanceled()
+
         // $var->where()
         if (element is MethodReference) {
             MethodUtils.findMethodsInTree(
@@ -108,6 +124,8 @@ class TableAndAliasCollector(private val reference: DbReferenceExpression) {
             }
         }
 
+        ProgressManager.checkCanceled()
+
         // Mode::when(true, function (Builder $query) { $query->where(''); });
         if (method.isInsideModelQueryClosure(reference.project)) {
             MethodUtils.findMethodsInTree(method.getParentOfClosure()).forEach {