Don't store analyze result longer than ModuleResolverProvider valid time

For synthetic files there might be file modifications without PsiModificationTracker.MODIFICATION_COUNT increment.

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheServiceImpl.kt

@@ -165,7 +165,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
         fun makeGlobalResolveSessionProvider(reuseDataFrom: ProjectResolutionFacade? = null,
                                              moduleFilter: (IdeaModuleInfo) -> Boolean = { true },
                                              allModules: Collection<IdeaModuleInfo>? = null
-        ): (GlobalContextImpl, Project) -> CachedValueProvider.Result<ModuleResolverProvider> {
+        ): (GlobalContextImpl, Project) -> ModuleResolverProvider {
             return globalResolveSessionProvider(
                     debugName,
                     targetPlatform,
@@ -316,7 +316,7 @@ private fun globalResolveSessionProvider(
         reuseDataFrom: ProjectResolutionFacade? = null,
         syntheticFiles: Collection<KtFile> = listOf(),
         allModules: Collection<IdeaModuleInfo>? = null // null means create resolvers for modules from idea model
-): (GlobalContextImpl, Project) -> CachedValueProvider.Result<ModuleResolverProvider> = { globalContext, project ->
+): (GlobalContextImpl, Project) -> ModuleResolverProvider = { globalContext, project ->
     val delegateResolverProvider = reuseDataFrom?.moduleResolverProvider
     val delegateResolverForProject = delegateResolverProvider?.resolverForProject ?: EmptyResolverForProject()
 
@@ -334,7 +334,8 @@ private fun globalResolveSessionProvider(
             AnalyzerFacadeProvider.getAnalyzerFacade(platform),
             syntheticFiles, delegateResolverForProject, moduleFilter,
             allModules,
-            builtIns
+            builtIns,
+            dependencies
     )
 
     if (newBuiltIns is JvmBuiltIns) {
@@ -342,7 +343,6 @@ private fun globalResolveSessionProvider(
         newBuiltIns.setOwnerModuleDescriptor(moduleResolverProvider.resolverForProject.descriptorForModule(sdkInfo))
     }
 
-    val allDependencies = dependencies + listOf(moduleResolverProvider.exceptionTracker)
+    moduleResolverProvider
-    CachedValueProvider.Result.create(moduleResolverProvider, allDependencies)
 }
 

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

@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.storage.ExceptionTracker
 
 fun createModuleResolverProvider(
         debugName: String,
@@ -45,7 +44,8 @@ fun createModuleResolverProvider(
         delegateResolver: ResolverForProject<IdeaModuleInfo>,
         moduleFilter: (IdeaModuleInfo) -> Boolean,
         allModules: Collection<IdeaModuleInfo>?,
-        builtIns: KotlinBuiltIns
+        builtIns: KotlinBuiltIns,
+        dependencies: Collection<Any>
 ): ModuleResolverProvider {
 
     val allModuleInfos = (allModules ?: collectAllModuleInfosFromIdeaModel(project)).toHashSet()
@@ -81,7 +81,7 @@ fun createModuleResolverProvider(
     return ModuleResolverProviderImpl(
             resolverForProject,
             builtIns,
-            globalContext
+            dependencies + listOf(globalContext.exceptionTracker)
     )
 }
 
@@ -111,15 +111,12 @@ private fun collectAllModuleInfosFromIdeaModel(project: Project): List<IdeaModul
 }
 
 interface ModuleResolverProvider {
-    val exceptionTracker: ExceptionTracker
     val resolverForProject: ResolverForProject<IdeaModuleInfo>
     val builtIns: KotlinBuiltIns
+    val cacheDependencies: Collection<Any>
 }
 
 class ModuleResolverProviderImpl(
         override val resolverForProject: ResolverForProject<IdeaModuleInfo>,
         override val builtIns: KotlinBuiltIns,
-        globalContext: GlobalContextImpl
+        override val cacheDependencies: Collection<Any>) : ModuleResolverProvider
-) : ModuleResolverProvider {
-    override val exceptionTracker: ExceptionTracker = globalContext.exceptionTracker
-}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt

@@ -32,10 +32,13 @@ internal class ProjectResolutionFacade(
         val debugString: String,
         val project: Project,
         val globalContext: GlobalContextImpl,
-        computeModuleResolverProvider: (GlobalContextImpl, Project) -> CachedValueProvider.Result<ModuleResolverProvider>
+        computeModuleResolverProvider: (GlobalContextImpl, Project) -> ModuleResolverProvider
 ) {
     private val cachedValue = CachedValuesManager.getManager(project).createCachedValue(
-            { computeModuleResolverProvider(globalContext, project) },
+            {
+                val resolverProvider = computeModuleResolverProvider(globalContext, project)
+                CachedValueProvider.Result.create(resolverProvider, resolverProvider.cacheDependencies)
+            },
             /* trackValue = */ false
     )
 
@@ -57,7 +60,9 @@ internal class ProjectResolutionFacade(
                         return PerFileAnalysisCache(file!!, resolverProvider.resolverForProject.resolverForModule(file.getModuleInfo()).componentProvider)
                     }
                 }
-                CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker)
+
+                val allDependencies = resolverProvider.cacheDependencies + listOf(PsiModificationTracker.MODIFICATION_COUNT)
+                CachedValueProvider.Result.create(results, allDependencies)
             }, false)
 
     fun getAnalysisResultsForElements(elements: Collection<KtElement>): AnalysisResult {