IJPL-149317 More explicit locks.

GitOrigin-RevId: 95f64ac7da5066d2efb212d4e7cfc2cb98543ac1

platform/collaboration-tools/src/com/intellij/collaboration/ui/codereview/editor/editorComponentInlaysUtil.kt

@@ -11,6 +11,7 @@ import com.intellij.collaboration.ui.util.DimensionRestrictions
 import com.intellij.collaboration.util.HashingUtil
 import com.intellij.openapi.application.ModalityState
 import com.intellij.openapi.application.asContextElement
+import com.intellij.openapi.application.writeIntentReadAction
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.diagnostic.getOrLogException
 import com.intellij.openapi.editor.*
@@ -85,7 +86,9 @@ private suspend fun <VM : EditorMapped> EditorEx.doRenderInlays(
     vmsFlow.map {
       createCustomHashingStrategySet(vmHashingStrategy).apply { addAll(it) }
     }.collect {
-      positionKeeper.savePosition()
+      writeIntentReadAction {
+        positionKeeper.savePosition()
+      }
 
       // remove missing
       val iter = controllersByVmKey.iterator()
@@ -105,10 +108,12 @@ private suspend fun <VM : EditorMapped> EditorEx.doRenderInlays(
         }
       }
 
-      // immediately validate the editor to recalculate the size with inlays
+      writeIntentReadAction {
-      editor.contentComponent.validate()
+        // immediately validate the editor to recalculate the size with inlays
-      positionKeeper.restorePosition(true)
+        editor.contentComponent.validate()
-      editor.contentComponent.repaint()
+        positionKeeper.restorePosition(true)
+        editor.contentComponent.repaint()
+      }
     }
     awaitCancellation()
   }
@@ -128,19 +133,21 @@ private suspend fun <VM : EditorMapped> controlInlay(vm: VM, editor: EditorEx, r
         combine(lineFlow, visibleFlow, ::Pair)
       }.distinctUntilChanged()
         .collect { (line, isVisible) ->
-          val currentInlay = inlay
+          writeIntentReadAction {
-          if (line != null && isVisible) {
+            val currentInlay = inlay
-            runCatching {
+            if (line != null && isVisible) {
-              val offset = editor.document.getLineEndOffset(line)
+              runCatching {
-              if (currentInlay == null || !currentInlay.isValid || currentInlay.offset != offset) {
+                val offset = editor.document.getLineEndOffset(line)
-                currentInlay?.let(Disposer::dispose)
+                if (currentInlay == null || !currentInlay.isValid || currentInlay.offset != offset) {
-                inlay = insertComponent(vm, rendererFactory, editor, offset)
+                  currentInlay?.let(Disposer::dispose)
-              }
+                  inlay = insertComponent(vm, rendererFactory, editor, offset)
-            }.getOrLogException(LOG)
+                }
-          }
+              }.getOrLogException(LOG)
-          else if (currentInlay != null) {
+            }
-            Disposer.dispose(currentInlay)
+            else if (currentInlay != null) {
-            inlay = null
+              Disposer.dispose(currentInlay)
+              inlay = null
+            }
           }
         }
       awaitCancellation()

platform/core-api/api-dump-unreviewed.txt

@@ -6244,8 +6244,6 @@ f:com.intellij.util.concurrency.ThreadingAssertions
 - s:assertReadAccess():V
 - s:assertWriteAccess():V
 - s:assertWriteIntentReadAccess():V
-- s:isImplicitLockOnEDT():Z
-- s:setImplicitLockOnEDT(Z):V
 - s:softAssertBackgroundThread():V
 - s:softAssertEventDispatchThread():V
 - s:softAssertReadAccess():V

platform/core-api/src/com/intellij/util/concurrency/ThreadingAssertions.java

@@ -32,16 +32,12 @@ public final class ThreadingAssertions {
   @VisibleForTesting
   public static final String MUST_EXECUTE_IN_READ_ACTION =
     "Read access is allowed from inside read-action only (see Application.runReadAction())";
-  private static final String MUST_EXECUTE_IN_READ_ACTION_EXPLICIT =
-    "Read access is allowed from inside explicit read-action only (see Application.runReadAction()). Now implicit WriteIntentReadAction.run() is used.";
   @Internal
   @VisibleForTesting
   public static final String MUST_NOT_EXECUTE_IN_READ_ACTION =
     "Must not execute inside read action";
   private static final String MUST_EXECUTE_IN_WRITE_INTENT_READ_ACTION =
     "Access is allowed from write thread only";
-  private static final String MUST_EXECUTE_IN_WRITE_INTENT_READ_ACTION_EXPLICIT =
-    "Access is allowed from write thread only with explicit WriteIntentReadAction.run(). Now implicit WriteIntentReadAction.run() is used.";
   @Internal
   @VisibleForTesting
   public static final String MUST_EXECUTE_IN_WRITE_ACTION =
@@ -57,8 +53,6 @@ public final class ThreadingAssertions {
 
   private static final String DOCUMENTATION_URL = "https://jb.gg/ij-platform-threading";
 
-  private static boolean implicitLock = false;
-
   /**
    * Asserts that the current thread is the event dispatch thread.
    *
@@ -117,17 +111,6 @@ public final class ThreadingAssertions {
     if (!ApplicationManager.getApplication().isReadAccessAllowed()) {
       throwThreadAccessException(MUST_EXECUTE_IN_READ_ACTION);
     }
-    else if (isImplicitLockOnEDT()) {
-      reportImplicitRead();
-    }
-  }
-
-  /**
-   * Reports message about implicit read to logger at error level
-   */
-  @Internal
-  public static void reportImplicitRead() {
-    getLogger().error(createThreadAccessException(MUST_EXECUTE_IN_READ_ACTION_EXPLICIT));
   }
 
   /**
@@ -165,17 +148,6 @@ public final class ThreadingAssertions {
     if (!ApplicationManager.getApplication().isWriteIntentLockAcquired()) {
       throwWriteIntentReadAccess();
     }
-    else if (isImplicitLockOnEDT()) {
-      reportImplicitWriteIntent();
-    }
-  }
-
-  /**
-   * Reports message about implicit read to logger at error level
-   */
-  @Internal
-  public static void reportImplicitWriteIntent() {
-    getLogger().error(createThreadAccessException(MUST_EXECUTE_IN_WRITE_INTENT_READ_ACTION_EXPLICIT));
   }
 
   /**
@@ -216,16 +188,4 @@ public final class ThreadingAssertions {
   private static @NotNull String describe(@Nullable Thread o) {
     return o == null ? "null" : o + " " + System.identityHashCode(o);
   }
-
-  public static boolean isImplicitLockOnEDT() {
-    if (!EDT.isCurrentThreadEdt())
-      return false;
-    return implicitLock;
-  }
-
-  public static void setImplicitLockOnEDT(boolean implicitLock) {
-    if (!EDT.isCurrentThreadEdt())
-      return;
-    ThreadingAssertions.implicitLock = implicitLock;
-  }
 }

platform/platform-impl/src/com/intellij/codeInsight/inline/completion/InlineCompletionHandler.kt

@@ -526,7 +526,9 @@ class InlineCompletionHandler(
   @RequiresEdt
   private fun traceBlocking(event: InlineCompletionEventType) {
     ThreadingAssertions.assertEventDispatchThread()
-    eventListeners.getMulticaster().on(event)
+    WriteIntentReadAction.run {
+      eventListeners.getMulticaster().on(event)
+    }
   }
 
   @RequiresEdt

platform/platform-impl/src/com/intellij/ide/IdeEventQueue.kt

@@ -1041,14 +1041,7 @@ internal fun performActivity(e: AWTEvent, needWIL: Boolean, runnable: () -> Unit
   else {
     val runnableWithWIL =
       if (needWIL) {
-        {
+        { WriteIntentReadAction.run(runnable) }
-          ThreadingAssertions.setImplicitLockOnEDT(true)
-          try {
-            WriteIntentReadAction.run(runnable)
-          } finally {
-            ThreadingAssertions.setImplicitLockOnEDT(false)
-          }
-        }
       }
       else {
         runnable

platform/platform-impl/src/com/intellij/openapi/application/impl/AnyThreadWriteThreadingSupport.kt

@@ -81,13 +81,10 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
       is WriteIntentPermit, is WritePermit -> release = false
     }
 
-    val prevImplicitLock = ThreadingAssertions.isImplicitLockOnEDT()
     try {
-      ThreadingAssertions.setImplicitLockOnEDT(false)
       return computation.compute()
     }
     finally {
-      ThreadingAssertions.setImplicitLockOnEDT(prevImplicitLock)
       if (release) {
         ts.release()
       }
@@ -109,21 +106,10 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
 
   override fun isWriteIntentLocked(): Boolean {
     val ts = myState.get()
-    // check for implicit
-    if (ts.hasWriteIntent && ThreadingAssertions.isImplicitLockOnEDT()) {
-      ThreadingAssertions.reportImplicitWriteIntent()
-    }
     return ts.hasWrite || ts.hasWriteIntent
   }
 
-  override fun isReadAccessAllowed(): Boolean {
+  override fun isReadAccessAllowed(): Boolean = myState.get().hasPermit
-    val ts = myState.get()
-    // check for implicit
-    if (ts.hasWriteIntent && ThreadingAssertions.isImplicitLockOnEDT()) {
-      ThreadingAssertions.reportImplicitRead()
-    }
-    return ts.hasPermit
-  }
 
   override fun executeOnPooledThread(action: Runnable, expired: BooleanSupplier): Future<*> {
     val actionDecorated = decorateRunnable(action)
@@ -235,17 +221,10 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
     fireBeforeReadActionStart(clazz)
     val ts = myState.get()
     if (ts.hasPermit) {
-      val prevImplicitLock = ThreadingAssertions.isImplicitLockOnEDT()
+      fireReadActionStarted(clazz)
-      ThreadingAssertions.setImplicitLockOnEDT(false)
+      val rv = block.compute()
-      try {
+      fireReadActionFinished(clazz)
-        fireReadActionStarted(clazz)
+      return rv
-        val rv = block.compute()
-        fireReadActionFinished(clazz)
-        return rv
-      }
-      finally {
-        ThreadingAssertions.setImplicitLockOnEDT(prevImplicitLock)
-      }
     }
     else {
       ts.permit = tryGetReadPermit()
@@ -277,8 +256,6 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
           } while (ts.permit == null)
         }
       }
-      val prevImplicitLock = ThreadingAssertions.isImplicitLockOnEDT()
-      ThreadingAssertions.setImplicitLockOnEDT(false)
       try {
         fireReadActionStarted(clazz)
         val rv = block.compute()
@@ -286,7 +263,6 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
         return rv
       }
       finally {
-        ThreadingAssertions.setImplicitLockOnEDT(prevImplicitLock)
         ts.release()
         fireAfterReadActionFinished(clazz)
       }
@@ -296,16 +272,9 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
   override fun tryRunReadAction(action: Runnable): Boolean {
     val ts = myState.get()
     if (ts.hasPermit) {
-      val prevImplicitLock = ThreadingAssertions.isImplicitLockOnEDT()
+      fireReadActionStarted(action.javaClass)
-      ThreadingAssertions.setImplicitLockOnEDT(false)
+      action.run()
-      try {
+      fireReadActionFinished(action.javaClass)
-        fireReadActionStarted(action.javaClass)
-        action.run()
-        fireReadActionFinished(action.javaClass)
-      }
-      finally {
-        ThreadingAssertions.setImplicitLockOnEDT(prevImplicitLock)
-      }
       return true
     }
     else {
@@ -314,8 +283,6 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
       if (!ts.hasPermit) {
         return false
       }
-      val prevImplicitLock = ThreadingAssertions.isImplicitLockOnEDT()
-      ThreadingAssertions.setImplicitLockOnEDT(false)
       try {
         fireReadActionStarted(action.javaClass)
         action.run()
@@ -323,7 +290,6 @@ internal object AnyThreadWriteThreadingSupport: ThreadingSupport {
         return true
       }
       finally {
-        ThreadingAssertions.setImplicitLockOnEDT(prevImplicitLock)
         ts.release()
         fireAfterReadActionFinished(action.javaClass)
       }

platform/platform-impl/src/com/intellij/openapi/editor/impl/EditorImpl.java

@@ -3733,7 +3733,7 @@ public final class EditorImpl extends UserDataHolderBase implements EditorEx, Hi
     mouseSelectionStateAlarm.cancel();
     if (myMouseSelectionState != MOUSE_SELECTION_STATE_NONE) {
       if (mouseSelectionStateResetRunnable == null) {
-        mouseSelectionStateResetRunnable = () -> resetMouseSelectionState(null, null);
+        mouseSelectionStateResetRunnable = () -> WriteIntentReadAction.run((Runnable)() -> resetMouseSelectionState(null, null));
       }
       mouseSelectionStateAlarm.request(Registry.intValue("editor.mouseSelectionStateResetTimeout"),
                                        ModalityState.stateForComponent(myEditorComponent),

platform/testFramework/junit5/test/showcase/JUnit5EditorFixtureTest.kt

@@ -2,6 +2,7 @@
 package com.intellij.testFramework.junit5.showcase
 
 import com.intellij.openapi.application.EDT
+import com.intellij.openapi.application.writeIntentReadAction
 import com.intellij.testFramework.junit5.TestApplication
 import com.intellij.testFramework.junit5.fixture.*
 import kotlinx.coroutines.Dispatchers
@@ -32,8 +33,10 @@ class JUnit5EditorFixtureTest {
   fun `caret position in editors`() {
     runBlocking {
       withContext(Dispatchers.EDT) {
-        localEditor.get().caretModel.moveToOffset(2)
+        writeIntentReadAction {
-        Assertions.assertEquals(2, localEditor.get().caretModel.offset)
+          localEditor.get().caretModel.moveToOffset(2)
+          Assertions.assertEquals(2, localEditor.get().caretModel.offset)
+        }
       }
     }
   }
@@ -42,8 +45,10 @@ class JUnit5EditorFixtureTest {
   fun `selection in editors`() {
     runBlocking {
       withContext(Dispatchers.EDT) {
-        localEditor.get().selectionModel.setSelection(1, 3)
+        writeIntentReadAction {
-        Assertions.assertEquals("bc", localEditor.get().selectionModel.selectedText)
+          localEditor.get().selectionModel.setSelection(1, 3)
+          Assertions.assertEquals("bc", localEditor.get().selectionModel.selectedText)
+        }
       }
     }
   }

platform/testFramework/src/com/intellij/codeInsight/inline/completion/InlineCompletionLifecycleTestDSL.kt

@@ -85,7 +85,9 @@ class InlineCompletionLifecycleTestDSL(val fixture: CodeInsightTestFixture) {
     withContext(Dispatchers.EDT) {
       val lookup = fixture.lookup as? LookupImpl
       assertThat(lookup).isNotNull()
-      lookup!!.hideLookup(false)
+      writeIntentReadAction {
+        lookup!!.hideLookup(false)
+      }
     }
   }
 

plugins/coverage/testSrc/com/intellij/coverage/view/CoverageGutterTest.kt

@@ -6,6 +6,7 @@ import com.intellij.coverage.CoverageIntegrationBaseTest
 import com.intellij.openapi.application.EDT
 import com.intellij.openapi.application.readAction
 import com.intellij.openapi.application.writeAction
+import com.intellij.openapi.application.writeIntentReadAction
 import com.intellij.openapi.editor.colors.CodeInsightColors
 import com.intellij.openapi.editor.impl.EditorImpl
 import com.intellij.openapi.editor.markup.FillingLineMarkerRenderer
@@ -187,7 +188,9 @@ internal suspend fun findEditor(project: Project, className: String): EditorImpl
 internal suspend fun closeEditor(project: Project, className: String) {
   val psiClass = getPsiClass(project, className)
   withContext(Dispatchers.EDT) {
-    FileEditorManager.getInstance(project).closeFile(psiClass.containingFile.virtualFile)
+    writeIntentReadAction {
+      FileEditorManager.getInstance(project).closeFile(psiClass.containingFile.virtualFile)
+    }
   }
 }
 

plugins/kotlin/gradle/gradle-java/tests.shared/test/org/jetbrains/kotlin/idea/codeInsight/gradle/AbstractGradleMultiFileQuickFixTest.kt

@@ -90,21 +90,23 @@ abstract class AbstractGradleMultiFileQuickFixTest : MultiplePluginVersionGradle
                 refreshRecursively(projectVFile)
 
                 withContext(Dispatchers.EDT) {
-                    PlatformTestUtil.assertDirectoriesEqual(
+                    writeIntentReadAction {
-                        expected,
+                        PlatformTestUtil.assertDirectoriesEqual(
-                        projectVFile,
+                            expected,
-                        fun(vFile: VirtualFile): Boolean {
+                            projectVFile,
-                            if (vFile.parent == projectVFile) {
+                            fun(vFile: VirtualFile): Boolean {
-                                when (vFile.name) {
+                                if (vFile.parent == projectVFile) {
-                                    ".gradle", "gradle", "build", "gradle.properties", "gradlew", "gradlew.bat", ".kotlin" -> return false
+                                    when (vFile.name) {
+                                        ".gradle", "gradle", "build", "gradle.properties", "gradlew", "gradlew.bat", ".kotlin" -> return false
+                                    }
                                 }
-                            }
 
-                            if (ignoreChangesInBuildScriptFiles && ".gradle" in vFile.name) return false
+                                if (ignoreChangesInBuildScriptFiles && ".gradle" in vFile.name) return false
 
-                            return additionalResultFileFilter(vFile)
+                                return additionalResultFileFilter(vFile)
-                        },
+                            },
-                    )
+                        )
+                    }
                 }
             }
 

python/ide/impl/src/com/intellij/pycharm/community/ide/impl/newProject/impl/emptyProject/PyV3EmptyProjectSettings.kt

@@ -3,6 +3,7 @@ package com.intellij.pycharm.community.ide.impl.newProject.impl.emptyProject
 
 import com.intellij.openapi.application.EDT
 import com.intellij.openapi.application.writeAction
+import com.intellij.openapi.application.writeIntentReadAction
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.vfs.VirtualFile
@@ -19,7 +20,9 @@ class PyV3EmptyProjectSettings(var generateWelcomeScript: Boolean = false) : PyV
       PyWelcome.prepareFile(module.project, baseDir)
     }
     withContext(Dispatchers.EDT) {
-      file.navigate(true)
+      writeIntentReadAction {
+        file.navigate(true)
+      }
     }
   }