IJPL-426: more clean concepts: rename FutureScanningRequestToken>IncompleteTaskToken and use it as a (closeable) marker

This way UnindexedFilesScanner should not track its success/failure state - the state will be tracked by the caller (UnindexedFilesScannerExecutor)

GitOrigin-RevId: 4a0cf3b9787ed7f7255d2ad23be46b9f9131c644

platform/lang-impl/api-dump-unreviewed.txt

@@ -29258,23 +29258,19 @@ com.intellij.util.indexing.customizingIteration.ModuleAwareContentEntityIterator
 - getIndexingProgressText():java.lang.String
 - a:getOrigin():com.intellij.util.indexing.roots.origin.ModuleAwareContentEntityOrigin
 - getRootsScanningProgressText():java.lang.String
-f:com.intellij.util.indexing.dependencies.AppIndexingDependenciesService
+*f:com.intellij.util.indexing.dependencies.AppIndexingDependenciesService
 - com.intellij.openapi.Disposable
-- sf:Companion:com.intellij.util.indexing.dependencies.AppIndexingDependenciesService$Companion
+- *sf:Companion:com.intellij.util.indexing.dependencies.AppIndexingDependenciesService$Companion
 - <init>():V
 - <init>(java.nio.file.Path):V
 - dispose():V
 - f:getCurrent():com.intellij.util.indexing.dependencies.AppIndexingDependenciesToken
 - f:getCurrentTokenInTest():com.intellij.util.indexing.dependencies.AppIndexingDependenciesToken
 - f:invalidateAllStamps(java.lang.String):V
-f:com.intellij.util.indexing.dependencies.AppIndexingDependenciesService$Companion
+*f:com.intellij.util.indexing.dependencies.AppIndexingDependenciesService$Companion
 com.intellij.util.indexing.dependencies.FileIndexingStamp
 - a:isSame(I):Z
 - a:store(java.util.function.IntConsumer):V
-f:com.intellij.util.indexing.dependencies.FutureScanningRequestToken
-- <init>():V
-- f:isSuccessful():Z
-- f:markSuccessful():V
 com.intellij.util.indexing.dependencies.IndexingRequestToken
 - a:getFileIndexingStamp(com.intellij.openapi.vfs.VirtualFile):com.intellij.util.indexing.dependencies.FileIndexingStamp
 f:com.intellij.util.indexing.dependencies.IndexingRequestTokenImpl
@@ -29289,25 +29285,6 @@ f:com.intellij.util.indexing.dependencies.IndexingRequestTokenImpl
 - getFileIndexingStamp(com.intellij.openapi.vfs.VirtualFile):com.intellij.util.indexing.dependencies.FileIndexingStamp
 - hashCode():I
 - toString():java.lang.String
-f:com.intellij.util.indexing.dependencies.ProjectIndexingDependenciesService
-- com.intellij.openapi.Disposable
-- sf:Companion:com.intellij.util.indexing.dependencies.ProjectIndexingDependenciesService$Companion
-- <init>(com.intellij.openapi.project.Project):V
-- <init>(java.nio.file.Path,com.intellij.util.indexing.dependencies.AppIndexingDependenciesService):V
-- f:completeToken(com.intellij.util.indexing.dependencies.FutureScanningRequestToken):V
-- f:completeToken(com.intellij.util.indexing.dependencies.ScanningRequestToken,Z):V
-- dispose():V
-- f:getAppIndexingRequestIdOfLastScanning():I
-- f:getLatestIndexingRequestToken():com.intellij.util.indexing.dependencies.IndexingRequestToken
-- sf:getNULL_STAMP():com.intellij.util.indexing.dependencies.FileIndexingStamp
-- f:getReadOnlyTokenForTest():com.intellij.util.indexing.dependencies.ScanningRequestToken
-- f:isScanningCompleted():Z
-- f:newFutureScanningToken():com.intellij.util.indexing.dependencies.FutureScanningRequestToken
-- f:newScanningToken():com.intellij.util.indexing.dependencies.ScanningRequestToken
-- f:newScanningTokenOnProjectOpen():com.intellij.util.indexing.dependencies.ScanningRequestToken
-- f:requestHeavyScanningOnProjectOpen(java.lang.String):V
-f:com.intellij.util.indexing.dependencies.ProjectIndexingDependenciesService$Companion
-- f:getNULL_STAMP():com.intellij.util.indexing.dependencies.FileIndexingStamp
 f:com.intellij.util.indexing.dependencies.ReadWriteFileIndexingStampImpl
 - com.intellij.util.indexing.dependencies.FileIndexingStamp
 - <init>(I):V

platform/lang-impl/src/com/intellij/util/indexing/UnindexedFilesScanner.kt

@@ -26,7 +26,6 @@ import com.intellij.util.gist.GistManagerImpl
 import com.intellij.util.indexing.FilesFilterScanningHandler.IdleFilesFilterScanningHandler
 import com.intellij.util.indexing.FilesFilterScanningHandler.UpdatingFilesFilterScanningHandler
 import com.intellij.util.indexing.IndexingProgressReporter.CheckPauseOnlyProgressIndicator
-import com.intellij.util.indexing.dependencies.FutureScanningRequestToken
 import com.intellij.util.indexing.dependencies.ProjectIndexingDependenciesService
 import com.intellij.util.indexing.dependencies.ScanningRequestToken
 import com.intellij.util.indexing.dependenciesCache.DependenciesIndexedStatusService
@@ -77,7 +76,7 @@ class UnindexedFilesScanner private constructor(private val myProject: Project,
   private val myIndex = FileBasedIndex.getInstance() as FileBasedIndexImpl
   private val myFilterHandler: FilesFilterScanningHandler
   private val myProvidedStatusMark: StatusMark?
-  private val myFutureScanningRequestToken: FutureScanningRequestToken
+  private val taskToken = myProject.getService(ProjectIndexingDependenciesService::class.java).newIncompleteTaskToken()
   private var flushQueueAfterScanning = true
   private val scanningHistory = ProjectScanningHistoryImpl(myProject, indexingReason, scanningType)
 
@@ -130,7 +129,6 @@ class UnindexedFilesScanner private constructor(private val myProject: Project,
       !myOnProjectOpen ||
       isIndexingFilesFilterUpToDate || this.predefinedIndexableFilesIterators == null,
       "Should request full scanning on project open")
-    myFutureScanningRequestToken = myProject.getService(ProjectIndexingDependenciesService::class.java).newFutureScanningToken()
   }
 
   private fun defaultHideProgressInSmartModeStrategy(): Boolean {
@@ -163,8 +161,6 @@ class UnindexedFilesScanner private constructor(private val myProject: Project,
     }
     LOG.debug("Merged $this task")
 
-    oldTask.myFutureScanningRequestToken.markSuccessful() // fixme: non-idempotent
-    myFutureScanningRequestToken.markSuccessful()         // fixme: non-idempotent
     LOG.assertTrue(!(startCondition != null && oldTask.startCondition != null), "Merge of two start conditions is not implemented")
     val mergedHideProgress: Boolean?
     if (shouldHideProgressInSmartMode == null) {
@@ -210,8 +206,6 @@ class UnindexedFilesScanner private constructor(private val myProject: Project,
     markStage(ProjectScanningHistoryImpl.Stage.CollectingIndexableFiles) {
       val projectIndexingDependenciesService = myProject.getService(ProjectIndexingDependenciesService::class.java)
       val scanningRequest = if (myOnProjectOpen) projectIndexingDependenciesService.newScanningTokenOnProjectOpen() else projectIndexingDependenciesService.newScanningToken()
-      myFutureScanningRequestToken.markSuccessful()
-      projectIndexingDependenciesService.completeToken(myFutureScanningRequestToken)
 
       try {
         ScanningSession(myProject, scanningHistory, forceReindexingTrigger, myFilterHandler, indicator, progressReporter, scanningRequest)
@@ -610,8 +604,7 @@ class UnindexedFilesScanner private constructor(private val myProject: Project,
 
   override fun close() {
     if (!myProject.isDisposed) {
-      myProject.getServiceIfCreated(ProjectIndexingDependenciesService::class.java)
-        ?.completeToken(myFutureScanningRequestToken)
+      myProject.getServiceIfCreated(ProjectIndexingDependenciesService::class.java)?.completeToken(taskToken)
     }
   }
 

platform/lang-impl/src/com/intellij/util/indexing/UnindexedFilesScannerExecutorImpl.kt

@@ -16,6 +16,7 @@ import com.intellij.openapi.util.NlsContexts.ProgressText
 import com.intellij.platform.util.coroutines.namedChildScope
 import com.intellij.util.gist.GistManager
 import com.intellij.util.gist.GistManagerImpl
+import com.intellij.util.indexing.dependencies.ProjectIndexingDependenciesService
 import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.coroutines.*
@@ -87,11 +88,12 @@ class UnindexedFilesScannerExecutorImpl(private val project: Project, cs: Corout
             LOG.info("Task finished: $task")
           }
           catch (t: Throwable) {
-            LOG.info("Task canceled $task")
+            LOG.info("Task interrupted: $task. ${t.message}")
+            project.service<ProjectIndexingDependenciesService>().requestHeavyScanningOnProjectOpen("Task interrupted: $task")
             checkCanceled() // this will re-throw cancellation
 
             // other exceptions: log and forget
-            LOG.error("Failed to execute task $task. ${t.message}", t)
+            LOG.error("Failed to execute task $task", t)
           }
           finally {
             task.close()

platform/lang-impl/src/com/intellij/util/indexing/dependencies/AppIndexingDependenciesService.kt

@@ -11,6 +11,7 @@ import com.intellij.serviceContainer.NonInjectable
 import com.intellij.util.application
 import com.intellij.util.concurrency.annotations.RequiresBackgroundThread
 import com.intellij.util.indexing.dependencies.IndexingDependenciesFingerprint.Companion.NULL_FINGERPRINT
+import org.jetbrains.annotations.ApiStatus.Experimental
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.annotations.VisibleForTesting
 import java.io.IOException
@@ -20,6 +21,7 @@ import java.util.concurrent.atomic.AtomicReference
 import kotlin.io.path.deleteIfExists
 import kotlin.math.max
 
+@Experimental
 @Service(Service.Level.APP)
 class AppIndexingDependenciesService @NonInjectable @VisibleForTesting constructor(storagePath: Path) : Disposable {
   companion object {

platform/lang-impl/src/com/intellij/util/indexing/dependencies/IncompleteTaskToken.kt

@@ -1,17 +1,11 @@
 // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.util.indexing.dependencies
 
+import org.jetbrains.annotations.ApiStatus.Internal
+
 /**
- * This class is to solve technical problem: you cannot obtain ScanningRequestToken from EDT, because
+ * This class is to solve a technical problem: you cannot obtain ScanningRequestToken from EDT, because
  * obtaining a token may trigger fingerprint calculation. FutureScanningRequestToken is EDT-safe.
  */
-class FutureScanningRequestToken {
-  @Volatile
-  private var successful = false
-
-  fun markSuccessful() {
-    successful = true
-  }
-
-  fun isSuccessful() = successful
-}
+@Internal
+class IncompleteTaskToken

platform/lang-impl/src/com/intellij/util/indexing/dependencies/ProjectIndexingDependenciesService.kt

@@ -12,6 +12,7 @@ import com.intellij.serviceContainer.NonInjectable
 import com.intellij.util.application
 import com.intellij.util.concurrency.annotations.RequiresBackgroundThread
 import com.intellij.util.indexing.dependencies.ProjectIndexingDependenciesStorage.Companion.DEFAULT_APP_INDEXING_REQUEST_ID_OF_LAST_COMPLETED_SCANNING
+import org.jetbrains.annotations.ApiStatus
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.annotations.VisibleForTesting
 import java.io.IOException
@@ -45,6 +46,7 @@ import kotlin.io.path.deleteIfExists
  * but persistence should not be dropped in other cases, because IndexingStamp is actually stored in VFS.
  *
  */
+@ApiStatus.Internal
 @Service(Service.Level.PROJECT)
 class ProjectIndexingDependenciesService @NonInjectable @VisibleForTesting constructor(storagePath: Path,
                                                                                        private val appIndexingDependenciesService: AppIndexingDependenciesService) : Disposable {
@@ -151,8 +153,8 @@ class ProjectIndexingDependenciesService @NonInjectable @VisibleForTesting const
     return token
   }
 
-  fun newFutureScanningToken(): FutureScanningRequestToken {
-    return FutureScanningRequestToken().also { registerIssuedToken(it) }
+  fun newIncompleteTaskToken(): IncompleteTaskToken {
+    return IncompleteTaskToken().also { registerIssuedToken(it) }
   }
 
   private fun registerIssuedToken(token: Any) {
@@ -164,8 +166,8 @@ class ProjectIndexingDependenciesService @NonInjectable @VisibleForTesting const
     }
   }
 
-  fun completeToken(token: FutureScanningRequestToken) {
-    completeTokenOrFutureToken(token, null, token.isSuccessful())
+  fun completeToken(token: IncompleteTaskToken) {
+    completeTokenOrFutureToken(token, null, true)
   }
 
   fun completeToken(token: ScanningRequestToken, isFullScanning: Boolean) {