Change AnalyzerFacade#createSetup to accept a list of synthetic files and a scope for physical source files

Make DeclarationProviderFactory a project service

idea/src/META-INF/plugin.xml

@@ -119,9 +119,6 @@
     <applicationService serviceInterface="org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache"
                         serviceImplementation="org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache"/>
 
-    <applicationService serviceInterface="org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService"
-                        serviceImplementation="org.jetbrains.jet.plugin.stubindex.resolve.PluginDeclarationProviderFactoryService"/>
-
     <projectService serviceInterface="org.jetbrains.jet.lang.resolve.java.JetFilesProvider"
                     serviceImplementation="org.jetbrains.jet.plugin.project.PluginJetFilesProvider"/>
 
@@ -158,6 +155,9 @@
     <projectService serviceInterface="org.jetbrains.jet.plugin.debugger.evaluate.KotlinEvaluateExpressionCache"
                     serviceImplementation="org.jetbrains.jet.plugin.debugger.evaluate.KotlinEvaluateExpressionCache"/>
 
+    <projectService serviceInterface="org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService"
+                    serviceImplementation="org.jetbrains.jet.plugin.stubindex.resolve.PluginDeclarationProviderFactoryService"/>
+
     <errorHandler implementation="org.jetbrains.jet.plugin.reporter.KotlinReportSubmitter"/>
 
     <internalFileTemplate name="Kotlin File"/>

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

@@ -26,15 +26,12 @@ import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.util.CachedValueProvider
 import org.jetbrains.jet.lang.resolve.BindingContext
 import com.intellij.openapi.components.ServiceManager
-import org.jetbrains.jet.lang.resolve.java.JetFilesProvider
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeProvider
 import org.jetbrains.jet.plugin.project.TargetPlatform
 import org.jetbrains.jet.plugin.project.TargetPlatform.*
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.project.TargetPlatformDetector
-import java.util.HashSet
-import org.jetbrains.jet.analyzer.AnalyzerFacade
 import org.jetbrains.jet.lang.psi.JetCodeFragment
 import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope
 
@@ -67,11 +64,9 @@ class KotlinCacheService(val project: Project) {
         fun getInstance(project: Project) = ServiceManager.getService(project, javaClass<KotlinCacheService>())!!
     }
 
-    private fun globalResolveSessionProvider(platform: TargetPlatform, syntheticFile: JetFile? = null) = {
-        val allFiles = JetFilesProvider.getInstance(project).allInScope(GlobalSearchScope.allScope(project))
-
-        val files = if (syntheticFile == null) allFiles else collectFilesForSyntheticFile(allFiles, syntheticFile)
-        val setup = AnalyzerFacadeProvider.getAnalyzerFacade(platform).createSetup(project, files)
+    private fun globalResolveSessionProvider(platform: TargetPlatform, syntheticFiles: Collection<JetFile> = listOf()) = {
+        val setup = AnalyzerFacadeProvider.getAnalyzerFacade(platform)
+                .createSetup(project, syntheticFiles, GlobalSearchScope.allScope(project))
         val resolveSessionForBodies = ResolveSessionForBodies(project, setup.getLazyResolveSession())
         CachedValueProvider.Result.create(
                 SessionAndSetup(
@@ -84,21 +79,6 @@ class KotlinCacheService(val project: Project) {
         )
     }
 
-    private fun collectFilesForSyntheticFile(allFiles: Collection<JetFile>, syntheticFile: JetFile): Collection<JetFile> {
-        val files = HashSet(allFiles)
-
-        // Add requested file to the list of files for searching declarations
-        files.add(syntheticFile)
-
-        val originalFile = syntheticFile.getOriginalFile()
-        if (syntheticFile != originalFile) {
-            // Given file can be a non-physical copy of the file in list (completion case). Remove the prototype file.
-            files.remove(originalFile)
-        }
-
-        return files
-    }
-
     private val globalCachesPerPlatform = mapOf(
             JVM to KotlinResolveCache(project, globalResolveSessionProvider(JVM)),
             JS to KotlinResolveCache(project, globalResolveSessionProvider(JS))
@@ -110,7 +90,7 @@ class KotlinCacheService(val project: Project) {
                     project,
                     globalResolveSessionProvider(
                             TargetPlatformDetector.getPlatform(file!!),
-                            file
+                            listOf(file)
                     )
             )
         }
@@ -152,7 +132,11 @@ class KotlinCacheService(val project: Project) {
         if (virtualFile == null) {
             return false
         }
-        return virtualFile in JetSourceFilterScope.kotlinSources(GlobalSearchScope.allScope(project))
+        return virtualFile in kotlinSourcesInProjectScope()
+    }
+
+    private fun kotlinSourcesInProjectScope(): GlobalSearchScope {
+        return JetSourceFilterScope.kotlinSources(GlobalSearchScope.allScope(project))
     }
 
     public fun <T> get(extension: CacheExtension<T>): T {

idea/src/org/jetbrains/jet/plugin/project/JSAnalyzerFacadeForIDEA.java

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.plugin.project;
 
 import com.intellij.openapi.project.Project;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzerFacade;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -33,7 +34,7 @@ public enum JSAnalyzerFacadeForIDEA implements AnalyzerFacade {
 
     @NotNull
     @Override
-    public Setup createSetup(@NotNull Project project, @NotNull Collection<JetFile> files) {
-        return new BasicSetup(AnalyzerFacadeForJS.getLazyResolveSession(files, new IDEAConfig(project)));
+    public Setup createSetup(@NotNull Project project, @NotNull Collection<JetFile> syntheticFiles, @NotNull GlobalSearchScope filesScope) {
+        return new BasicSetup(AnalyzerFacadeForJS.getLazyResolveSession(syntheticFiles, filesScope, new IDEAConfig(project)));
     }
 }

idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java

@@ -25,6 +25,7 @@ import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzerFacade;
@@ -32,8 +33,8 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.plugin.MainFunctionDetector;
 import org.jetbrains.jet.plugin.JetPluginUtil;
+import org.jetbrains.jet.plugin.MainFunctionDetector;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeProvider;
 import org.jetbrains.jet.plugin.project.ProjectStructureUtil;
 
@@ -83,7 +84,9 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im
         if (psiFile instanceof JetFile) {
             JetFile jetFile = (JetFile) psiFile;
             AnalyzerFacade facade = AnalyzerFacadeProvider.getAnalyzerFacadeForFile(jetFile);
-            ResolveSession resolveSession = facade.createSetup(jetFile.getProject(), Collections.singleton(jetFile)).getLazyResolveSession();
+            ResolveSession resolveSession =
+                    facade.createSetup(jetFile.getProject(), Collections.<JetFile>emptyList(), GlobalSearchScope.fileScope(jetFile))
+                            .getLazyResolveSession();
             MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(resolveSession);
             if (mainFunctionDetector.hasMain(jetFile.getDeclarations())) {
                 return jetFile;

idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactoryService.kt

@@ -17,29 +17,21 @@
 package org.jetbrains.jet.plugin.stubindex.resolve
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.Condition
-import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.util.Function
-import com.intellij.util.containers.ContainerUtil
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService
-import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope
 import org.jetbrains.jet.storage.StorageManager
-import org.jetbrains.jet.plugin.search.allScope
+import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope
 
 public class PluginDeclarationProviderFactoryService : DeclarationProviderFactoryService() {
 
-    override fun create(project: Project, storageManager: StorageManager, files: Collection<JetFile>): DeclarationProviderFactory {
-        val indexedSourcesScope = JetSourceFilterScope.kotlinSourcesAndLibraries(project.allScope())
-        val nonIndexedFiles = files.filter {
-            file ->
-            !file.isPhysical() || !indexedSourcesScope.contains(file.getVirtualFile()!!)
-        }
-        val physicalFilesScope = GlobalSearchScope.filesScope(project, files.filter { it.isPhysical() }.map { it.getVirtualFile()!! })
-        val indexedFilesScope = indexedSourcesScope.intersectWith(physicalFilesScope)
-
-        return PluginDeclarationProviderFactory(project, indexedFilesScope, storageManager, nonIndexedFiles)
+    override fun create(
+            project: Project,
+            storageManager: StorageManager,
+            syntheticFiles: Collection<JetFile>,
+            filesScope: GlobalSearchScope
+    ): DeclarationProviderFactory {
+        return PluginDeclarationProviderFactory(project, JetSourceFilterScope.kotlinSources(filesScope), storageManager, syntheticFiles)
     }
 }