From 68201c3e86b9b569c9e0e643c15b30cf79beaefb Mon Sep 17 00:00:00 2001
From: "Pavel V. Talanov" <talanov.pavel@gmail.com>
Date: Tue, 16 Sep 2014 17:23:15 +0400
Subject: [PATCH] Delegate to global cache when building ModuleResolverProvider
 for synthetic files

---
 .../caches/resolve/KotlinCacheService.kt      | 45 ++++++++++++++-----
 .../caches/resolve/ModuleDependencyMapper.kt  |  3 +-
 2 files changed, 36 insertions(+), 12 deletions(-)

diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt
index 5e2e49dac7d..e3caa44d29c 100644
--- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt
+++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt
@@ -65,9 +65,9 @@ public class KotlinCacheService(val project: Project) {
     fun globalResolveSessionProvider(
             platform: TargetPlatform,
             dependencies: Collection<Any>,
+            moduleFilter: (IdeaModuleInfo) -> Boolean,
             reuseDataFromCache: KotlinResolveCache? = null,
-            syntheticFiles: Collection<JetFile> = listOf(),
-            moduleFilter: (IdeaModuleInfo) -> Boolean = { true }
+            syntheticFiles: Collection<JetFile> = listOf()
     ): () -> CachedValueProvider.Result<ModuleResolverProvider> = {
         val analyzerFacade = AnalyzerFacadeProvider.getAnalyzerFacade(platform)
         val delegateResolverProvider = reuseDataFromCache?.moduleResolverProvider ?: EmptyModuleResolverProvider
@@ -94,20 +94,43 @@ public class KotlinCacheService(val project: Project) {
     }
 
     private fun getGlobalCache(platform: TargetPlatform) = globalCachesPerPlatform[platform]!!.modulesCache
+    private fun getGlobalLibrariesCache(platform: TargetPlatform) = globalCachesPerPlatform[platform]!!.librariesCache
 
     private val syntheticFileCaches = object : SLRUCache<JetFile, KotlinResolveCache>(2, 3) {
         override fun createValue(file: JetFile?): KotlinResolveCache {
             val targetPlatform = TargetPlatformDetector.getPlatform(file!!)
-            return KotlinResolveCache(
-                    project,
-                    globalResolveSessionProvider(
-                            targetPlatform,
-                            syntheticFiles = listOf(file),
-                            reuseDataFromCache = globalCachesPerPlatform[targetPlatform]!!.librariesCache,
-                            moduleFilter = { !it.isLibraryClasses() },
-                            dependencies = listOf(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT)
+            val syntheticFileModule = file.getModuleInfo()
+            return when {
+                syntheticFileModule is ModuleSourceInfo -> {
+                    val dependentModules = syntheticFileModule.getDependentModules()
+                    KotlinResolveCache(
+                            project,
+                            globalResolveSessionProvider(
+                                    targetPlatform,
+                                    syntheticFiles = listOf(file),
+                                    reuseDataFromCache = getGlobalCache(targetPlatform),
+                                    moduleFilter = { it in dependentModules },
+                                    dependencies = listOf(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT)
+                            )
                     )
-            )
+                }
+                else -> {
+                    if (syntheticFileModule.isLibraryClasses()) {
+                        LOG.error("Creating cache with synthetic file ($file) in classes of library $syntheticFileModule")
+                    }
+                    KotlinResolveCache(
+                            project,
+                            globalResolveSessionProvider(
+                                    targetPlatform,
+                                    syntheticFiles = listOf(file),
+                                    reuseDataFromCache = getGlobalLibrariesCache(targetPlatform),
+                                    moduleFilter = { it == syntheticFileModule },
+                                    dependencies = listOf(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT)
+                            )
+                    )
+                }
+            }
+
         }
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ModuleDependencyMapper.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ModuleDependencyMapper.kt
index 14f2ede6b1e..8a299ab78b7 100644
--- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ModuleDependencyMapper.kt
+++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ModuleDependencyMapper.kt
@@ -48,7 +48,8 @@ fun createModuleResolverProvider(
     val globalContext = (delegateProvider as? ModuleResolverProviderImpl)?.globalContext ?: GlobalContext()
 
     val syntheticFilesByModule = syntheticFiles.groupBy { it.getModuleInfo() }
-    allModuleInfos.addAll(syntheticFilesByModule.keySet())
+    val syntheticFilesModules = syntheticFilesByModule.keySet()
+    allModuleInfos.addAll(syntheticFilesModules)
 
     val modulesToCreateResolversFor = allModuleInfos.filter(moduleFilter)