Libraries cache drops only on roots change

annotations/com/intellij/openapi/roots/annotations.xml

@@ -26,4 +26,8 @@
       name='com.intellij.openapi.roots.ProjectFileIndex.SERVICE com.intellij.openapi.roots.ProjectFileIndex getInstance(com.intellij.openapi.project.Project)'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
+    <item
+        name='com.intellij.openapi.roots.ProjectRootModificationTracker com.intellij.openapi.roots.ProjectRootModificationTracker getInstance(com.intellij.openapi.project.Project)'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
 </root>

annotations/com/intellij/psi/util/annotations.xml

@@ -3,7 +3,11 @@
       name='com.intellij.psi.util.CachedValueProvider.Result com.intellij.psi.util.CachedValueProvider.Result<T> create(T, java.lang.Object...)'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
-  <item
+    <item
+        name='com.intellij.psi.util.CachedValueProvider.Result com.intellij.psi.util.CachedValueProvider.Result&lt;T&gt; create(T, java.util.Collection&lt;?&gt;)'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+    <item
       name='com.intellij.psi.util.CachedValuesManager com.intellij.psi.util.CachedValue&lt;T&gt; createCachedValue(com.intellij.psi.util.CachedValueProvider&lt;T&gt;, boolean)'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>

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

@@ -33,13 +33,9 @@ import org.jetbrains.jet.plugin.project.TargetPlatform.*
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.project.TargetPlatformDetector
 import org.jetbrains.jet.lang.psi.JetCodeFragment
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
-import org.jetbrains.jet.lang.resolve.DescriptorUtils
-import org.jetbrains.jet.context.GlobalContext
 import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope
-import com.intellij.psi.PsiElement
 import org.jetbrains.jet.utils.keysToMap
+import com.intellij.openapi.roots.ProjectRootModificationTracker
 
 private val LOG = Logger.getInstance(javaClass<KotlinCacheService>())
 
@@ -68,6 +64,7 @@ public class KotlinCacheService(val project: Project) {
 
     fun globalResolveSessionProvider(
             platform: TargetPlatform,
+            dependencies: Collection<Any>,
             reuseDataFromCache: KotlinResolveCache? = null,
             syntheticFiles: Collection<JetFile> = listOf(),
             moduleFilter: (IdeaModuleInfo) -> Boolean = { true }
@@ -75,24 +72,24 @@ public class KotlinCacheService(val project: Project) {
         val analyzerFacade = AnalyzerFacadeProvider.getAnalyzerFacade(platform)
         val delegateResolverProvider = reuseDataFromCache?.moduleResolverProvider ?: EmptyModuleResolverProvider
         val moduleResolverProvider = createModuleResolverProvider(project, analyzerFacade, syntheticFiles, delegateResolverProvider, moduleFilter)
-        CachedValueProvider.Result.create(
+        val allDependencies = dependencies + listOf(moduleResolverProvider.exceptionTracker)
-                moduleResolverProvider,
+        CachedValueProvider.Result.create(moduleResolverProvider, allDependencies)
-                PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT,
-                moduleResolverProvider.exceptionTracker
-        )
     }
 
     private val globalCachesPerPlatform = listOf(JVM, JS).keysToMap { platform -> GlobalCache(platform) }
 
     private inner class GlobalCache(platform: TargetPlatform) {
         val librariesCache = KotlinResolveCache(
-                project, globalResolveSessionProvider(platform, moduleFilter = { it.isLibraryClasses() })
+                project, globalResolveSessionProvider(platform,
+                                                      moduleFilter = { it.isLibraryClasses() },
+                                                      dependencies = listOf(ProjectRootModificationTracker.getInstance(project)))
         )
 
         val modulesCache = KotlinResolveCache(
                 project, globalResolveSessionProvider(platform,
                                                       reuseDataFromCache = librariesCache,
-                                                      moduleFilter = { !it.isLibraryClasses() })
+                                                      moduleFilter = { !it.isLibraryClasses() },
+                                                      dependencies = listOf(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT))
         )
     }
 
@@ -107,7 +104,8 @@ public class KotlinCacheService(val project: Project) {
                             targetPlatform,
                             syntheticFiles = listOf(file),
                             reuseDataFromCache = globalCachesPerPlatform[targetPlatform]!!.librariesCache,
-                            moduleFilter = { !it.isLibraryClasses() }
+                            moduleFilter = { !it.isLibraryClasses() },
+                            dependencies = listOf(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT)
                     )
             )
         }