Log when libraries cache is dropped because of ProcessCanceledException

Hope it can give insight on how often this happens

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt

@@ -67,11 +67,18 @@ public class KotlinCacheService(val project: Project) {
             dependencies: Collection<Any>,
             moduleFilter: (IdeaModuleInfo) -> Boolean,
             reuseDataFromCache: KotlinResolveCache? = null,
-            syntheticFiles: Collection<JetFile> = listOf()
+            syntheticFiles: Collection<JetFile> = listOf(),
+            logProcessCanceled: Boolean = false
     ): () -> CachedValueProvider.Result<ModuleResolverProvider> = {
         val analyzerFacade = AnalyzerFacadeProvider.getAnalyzerFacade(platform)
         val delegateResolverProvider = reuseDataFromCache?.moduleResolverProvider ?: EmptyModuleResolverProvider
-        val moduleResolverProvider = createModuleResolverProvider(project, analyzerFacade, syntheticFiles, delegateResolverProvider, moduleFilter)
+        val globalContext = (delegateResolverProvider as? ModuleResolverProviderImpl)?.globalContext
+                                    ?.withCompositeExceptionTrackerUnderSameLock()
+                            ?: GlobalContext(logProcessCanceled)
+
+        val moduleResolverProvider = createModuleResolverProvider(
+                project, globalContext, analyzerFacade, syntheticFiles, delegateResolverProvider, moduleFilter
+        )
         val allDependencies = dependencies + listOf(moduleResolverProvider.exceptionTracker)
         CachedValueProvider.Result.create(moduleResolverProvider, allDependencies)
     }
@@ -81,6 +88,7 @@ public class KotlinCacheService(val project: Project) {
     private inner class GlobalCache(platform: TargetPlatform) {
         val librariesCache = KotlinResolveCache(
                 project, globalResolveSessionProvider(platform,
+                                                      logProcessCanceled = true,
                                                       moduleFilter = { it.isLibraryClasses() },
                                                       dependencies = listOf(ProjectRootModificationTracker.getInstance(project)))
         )

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ModuleDependencyMapper.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.plugin.caches.resolve
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.jet.context.GlobalContext
 import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.module.ModuleManager
 import org.jetbrains.jet.utils.keysToMap
@@ -38,6 +37,7 @@ import org.jetbrains.jet.context.GlobalContextImpl
 
 fun createModuleResolverProvider(
         project: Project,
+        globalContext: GlobalContextImpl,
         analyzerFacade: AnalyzerFacade<ResolverForModule, JvmPlatformParameters>,
         syntheticFiles: Collection<JetFile>,
         delegateProvider: ModuleResolverProvider,
@@ -46,10 +46,6 @@ fun createModuleResolverProvider(
 
     val allModuleInfos = collectAllModuleInfosFromIdeaModel(project).toHashSet()
 
-    val globalContext =
-            (delegateProvider as? ModuleResolverProviderImpl)?.globalContext?.withCompositeExceptionTrackerUnderSameLock()
-            ?: GlobalContext()
-
     val syntheticFilesByModule = syntheticFiles.groupBy { it.getModuleInfo() }
     val syntheticFilesModules = syntheticFilesByModule.keySet()
     allModuleInfos.addAll(syntheticFilesModules)

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/globalContextUtils.kt

@@ -19,6 +19,8 @@ package org.jetbrains.jet.plugin.caches.resolve
 import org.jetbrains.jet.context.GlobalContextImpl
 import org.jetbrains.jet.storage.LockBasedStorageManager
 import org.jetbrains.jet.storage.ExceptionTracker
+import com.intellij.openapi.progress.ProcessCanceledException
+import com.intellij.openapi.diagnostic.Logger
 
 fun GlobalContextImpl.withCompositeExceptionTrackerUnderSameLock(): GlobalContextImpl {
     val newExceptionTracker = CompositeExceptionTracker(this.exceptionTracker)
@@ -26,8 +28,27 @@ fun GlobalContextImpl.withCompositeExceptionTrackerUnderSameLock(): GlobalContex
     return GlobalContextImpl(newStorageManager, newExceptionTracker)
 }
 
-private class CompositeExceptionTracker(val delegate: ExceptionTracker): ExceptionTracker() {
+private class CompositeExceptionTracker(val delegate: ExceptionTracker) : ExceptionTracker() {
     override fun getModificationCount(): Long {
-        return super<ExceptionTracker>.getModificationCount() + delegate.getModificationCount()
+        return super.getModificationCount() + delegate.getModificationCount()
     }
 }
+
+private class ExceptionTrackerWithProcessCanceledReport() : ExceptionTracker() {
+    override fun handleException(throwable: Throwable): RuntimeException {
+        if (throwable is ProcessCanceledException) {
+            LOG.info("ProcessCancelException was thrown while analyzing libraries. Cache has to be rebuilt.")
+        }
+        throw super.handleException(throwable)
+    }
+
+
+    class object {
+        val LOG = Logger.getInstance(javaClass<ExceptionTrackerWithProcessCanceledReport>())
+    }
+}
+
+public fun GlobalContext(logProcessCanceled: Boolean): GlobalContextImpl {
+    val tracker = if (logProcessCanceled) ExceptionTrackerWithProcessCanceledReport() else ExceptionTracker()
+    return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(tracker), tracker)
+}