FileScopeProviderImpl dependencies

compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaBeansExtensionsScope.kt

@@ -72,7 +72,7 @@ interface SyntheticJavaBeansPropertyDescriptor : PropertyDescriptor {
     }
 }
 
-class AdditionalScopesWithJavaSyntheticExtensions(storageManager: StorageManager) : FileScopeProvider.AdditionalScopes() {
+class AdditionalScopesWithJavaSyntheticExtensions(storageManager: StorageManager) : FileScopeProvider.AdditionalScopes {
     private val scope = JavaBeansExtensionsScope(storageManager)
 
     override fun scopes(file: JetFile) = listOf(scope)

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt

@@ -28,10 +28,8 @@ public interface FileScopeProvider {
         }
     }
 
-    public open class AdditionalScopes {
-        public open fun scopes(file: JetFile): List<JetScope> {
-            return emptyList()
-        }
+    public interface AdditionalScopes {
+        public fun scopes(file: JetFile): List<JetScope>
     }
 }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt

@@ -16,29 +16,75 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.JetCodeFragment
 import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.JetImportsFactory
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.NoSubpackagesInPackageScope
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.get
+import org.jetbrains.kotlin.utils.sure
+import java.util.*
 
 public class FileScopeProviderImpl(
-        private val resolveSession: ResolveSession,
+        private val topLevelDescriptorProvider: TopLevelDescriptorProvider,
+        private val storageManager: StorageManager,
+        private val moduleDescriptor: ModuleDescriptor,
+        private val qualifiedExpressionResolver: QualifiedExpressionResolver,
+        private val bindingTrace: BindingTrace,
+        private val jetImportsFactory: JetImportsFactory,
         private val additionalScopes: Iterable<FileScopeProvider.AdditionalScopes>
 ) : FileScopeProvider {
 
-    private val defaultImports by resolveSession.getStorageManager().createLazyValue {
-        val defaultImports = resolveSession.getModuleDescriptor().defaultImports
-        resolveSession.getJetImportsFactory().createImportDirectives(defaultImports)
+    private val defaultImports by storageManager.createLazyValue {
+        jetImportsFactory.createImportDirectives(moduleDescriptor.defaultImports)
     }
 
-    private val fileScopes = resolveSession.getStorageManager().createMemoizedFunction { file: JetFile -> createFileScope(file) }
+    private val fileScopes = storageManager.createMemoizedFunction { file: JetFile -> createFileScope(file) }
 
     override fun getFileScope(file: JetFile) = fileScopes(file)
 
     private fun createFileScope(file: JetFile): LazyFileScope {
-        val tempTrace = TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve")
-        return LazyFileScope.create(
-                resolveSession, file, defaultImports, additionalScopes.flatMap { it.scopes(file) },
-                resolveSession.getTrace(), tempTrace, "LazyFileScope for file " + file.getName()
-        )
+        val debugName = "LazyFileScope for file " + file.getName()
+        val tempTrace = TemporaryBindingTrace.create(bindingTrace, "Transient trace for default imports lazy resolve")
+
+        val imports = if (file is JetCodeFragment)
+            file.importsAsImportList()?.getImports() ?: listOf()
+        else
+            file.getImportDirectives()
+
+        val packageView = moduleDescriptor.getPackage(file.getPackageFqName())
+        val packageFragment = topLevelDescriptorProvider.getPackageFragment(file.getPackageFqName())
+                .sure { "Could not find fragment ${file.getPackageFqName()} for file ${file.getName()}" }
+
+        val aliasImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AliasImportsIndexed(imports), bindingTrace)
+        val allUnderImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AllUnderImportsIndexed(imports), bindingTrace)
+        val defaultAliasImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AliasImportsIndexed(defaultImports), tempTrace)
+        val defaultAllUnderImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AllUnderImportsIndexed(defaultImports), tempTrace)
+
+        val scopeChain = ArrayList<JetScope>()
+
+        scopeChain.add(LazyImportScope(packageFragment, aliasImportResolver, LazyImportScope.FilteringKind.ALL, "Alias imports in $debugName"))
+
+        scopeChain.add(NoSubpackagesInPackageScope(packageView)) //TODO: problems with visibility too
+        scopeChain.add(SubpackagesScope(moduleDescriptor, FqName.ROOT))
+
+        scopeChain.add(LazyImportScope(packageFragment, defaultAliasImportResolver, LazyImportScope.FilteringKind.ALL, "Default alias imports in $debugName"))
+
+        scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "Default all under imports in $debugName (visible classes)"))
+        scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "All under imports in $debugName (visible classes)"))
+
+        scopeChain.addAll(additionalScopes.flatMap { it.scopes(file) })
+
+        scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "Default all under imports in $debugName (invisible classes only)"))
+        scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "All under imports in $debugName (invisible classes only)"))
+
+        return LazyFileScope(scopeChain, aliasImportResolver, allUnderImportResolver, packageFragment, debugName)
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
 import org.jetbrains.kotlin.name.FqName
@@ -24,12 +25,14 @@ import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.JetImportDirective
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.NoSubpackagesInPackageScope
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.sure
 import java.util.ArrayList
 
-class LazyFileScope private constructor(
+class LazyFileScope(
         scopeChain: List<JetScope>,
         private val aliasImportResolver: LazyImportResolver,
         private val allUnderImportResolver: LazyImportResolver,
@@ -50,50 +53,4 @@ class LazyFileScope private constructor(
             aliasImportResolver.forceResolveImportDirective(importDirective)
         }
     }
-
-    companion object Factory {
-        public fun create(
-                resolveSession: ResolveSession,
-                file: JetFile,
-                defaultImports: Collection<JetImportDirective>,
-                additionalScopes: List<JetScope>,
-                traceForImportResolve: BindingTrace,
-                traceForDefaultImportResolve: BindingTrace,
-                debugName: String
-        ): LazyFileScope {
-            val imports = if (file is JetCodeFragment)
-                file.importsAsImportList()?.getImports() ?: listOf()
-            else
-                file.getImportDirectives()
-
-            val moduleDescriptor = resolveSession.getModuleDescriptor()
-            val packageView = moduleDescriptor.getPackage(file.getPackageFqName())
-            val packageFragment = resolveSession.getPackageFragment(file.getPackageFqName())
-                    .sure { "Could not find fragment ${file.getPackageFqName()} for file ${file.getName()}" }
-
-            val aliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(imports), traceForImportResolve)
-            val allUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(imports), traceForImportResolve)
-            val defaultAliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(defaultImports), traceForDefaultImportResolve)
-            val defaultAllUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(defaultImports), traceForDefaultImportResolve)
-
-            val scopeChain = ArrayList<JetScope>()
-
-            scopeChain.add(LazyImportScope(packageFragment, aliasImportResolver, LazyImportScope.FilteringKind.ALL, "Alias imports in $debugName"))
-
-            scopeChain.add(NoSubpackagesInPackageScope(packageView)) //TODO: problems with visibility too
-            scopeChain.add(SubpackagesScope(moduleDescriptor, FqName.ROOT))
-
-            scopeChain.add(LazyImportScope(packageFragment, defaultAliasImportResolver, LazyImportScope.FilteringKind.ALL, "Default alias imports in $debugName"))
-
-            scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "Default all under imports in $debugName (visible classes)"))
-            scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "All under imports in $debugName (visible classes)"))
-
-            scopeChain.addAll(additionalScopes)
-
-            scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "Default all under imports in $debugName (invisible classes only)"))
-            scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "All under imports in $debugName (invisible classes only)"))
-
-            return LazyFileScope(scopeChain, aliasImportResolver, allUnderImportResolver, packageFragment, debugName)
-        }
-    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt

@@ -25,10 +25,12 @@ import org.jetbrains.kotlin.psi.JetImportDirective
 import org.jetbrains.kotlin.psi.JetPsiUtil
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.PlatformTypesMappedToKotlinChecker
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.util.collectionUtils.concat
 import org.jetbrains.kotlin.utils.Printer
@@ -64,12 +66,14 @@ class AliasImportsIndexed(allImports: Collection<JetImportDirective>) : IndexedI
 }
 
 class LazyImportResolver(
-        val resolveSession: ResolveSession,
+        val storageManager: StorageManager,
+        val qualifiedExpressionResolver: QualifiedExpressionResolver,
+        val fileScopeProvider: FileScopeProvider,
         val moduleDescriptor: ModuleDescriptor,
         val indexedImports: IndexedImports,
         private val traceForImportResolve: BindingTrace
 ) {
-    private val importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction {
+    private val importedScopesProvider = storageManager.createMemoizedFunction {
         directive: JetImportDirective -> ImportDirectiveResolveCache(directive)
     }
 
@@ -87,7 +91,7 @@ class LazyImportResolver(
                 return status.scope
             }
 
-            return resolveSession.getStorageManager().compute {
+            return storageManager.compute {
                 val cachedStatus = importResolveStatus
                 if (cachedStatus != null && (cachedStatus.lookupMode == mode || cachedStatus.lookupMode == LookupMode.EVERYTHING)) {
                     cachedStatus.scope
@@ -96,8 +100,7 @@ class LazyImportResolver(
                     directiveUnderResolve = directive
 
                     try {
-                        val resolver = resolveSession.getQualifiedExpressionResolver()
-                        val directiveImportScope = resolver.processImportReference(
+                        val directiveImportScope = qualifiedExpressionResolver.processImportReference(
                                 directive, moduleDescriptor, traceForImportResolve, mode)
                         val descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
 
@@ -127,7 +130,7 @@ class LazyImportResolver(
 
         val status = importedScopesProvider(importDirective).importResolveStatus
         if (status != null && !status.descriptors.isEmpty()) {
-            val fileScope = resolveSession.getFileScopeProvider().getFileScope(importDirective.getContainingJetFile())
+            val fileScope = fileScopeProvider.getFileScope(importDirective.getContainingJetFile())
             reportConflictingImport(importDirective, fileScope, status.descriptors, traceForImportResolve)
         }
     }
@@ -181,7 +184,7 @@ class LazyImportResolver(
             }
             return target
         }
-        return resolveSession.getStorageManager().compute(::compute)
+        return storageManager.compute(::compute)
     }
 
     public fun <D : DeclarationDescriptor> collectFromImports(
@@ -189,7 +192,7 @@ class LazyImportResolver(
             lookupMode: LookupMode,
             descriptorsSelector: (JetScope, Name) -> Collection<D>
     ): Collection<D> {
-        return resolveSession.getStorageManager().compute {
+        return storageManager.compute {
             var descriptors: Collection<D>? = null
             for (directive in indexedImports.importsForName(name)) {
                 if (directive == directiveUnderResolve) {
@@ -264,7 +267,7 @@ class LazyImportScope(
         // we do not perform any filtering by visibility here because all descriptors from both visible/invisible filter scopes are to be added anyway
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
 
-        return importResolver.resolveSession.getStorageManager().compute {
+        return importResolver.storageManager.compute {
             importResolver.indexedImports.imports.flatMapTo(LinkedHashSet<PropertyDescriptor>()) { import ->
                 importResolver.getImportScope(import, LookupMode.EVERYTHING).getSyntheticExtensionProperties(receiverType)
             }
@@ -277,7 +280,7 @@ class LazyImportScope(
         // we do not perform any filtering by visibility here because all descriptors from both visible/invisible filter scopes are to be added anyway
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
 
-        return importResolver.resolveSession.getStorageManager().compute {
+        return importResolver.storageManager.compute {
             val descriptors = LinkedHashSet<DeclarationDescriptor>()
             for (directive in importResolver.indexedImports.imports) {
                 val importPath = directive.getImportPath() ?: continue