From 76b9ac0f636738b89f29bc7c424d145acdf92b8b Mon Sep 17 00:00:00 2001 From: Ilya Ryzhenkov Date: Fri, 17 Jul 2015 21:13:51 +0300 Subject: [PATCH] FileScopeProviderImpl dependencies --- .../synthetic/JavaBeansExtensionsScope.kt | 2 +- .../kotlin/resolve/lazy/FileScopeProvider.kt | 6 +- .../resolve/lazy/FileScopeProviderImpl.kt | 66 ++++++++++++++++--- .../kotlin/resolve/lazy/LazyFileScope.kt | 51 ++------------ .../kotlin/resolve/lazy/LazyImportScope.kt | 23 ++++--- 5 files changed, 76 insertions(+), 72 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaBeansExtensionsScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaBeansExtensionsScope.kt index 3c019f06ba5..c5deca72822 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaBeansExtensionsScope.kt +++ b/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) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt index 03e916e2f31..29854c8b2dc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt +++ b/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 { - return emptyList() - } + public interface AdditionalScopes { + public fun scopes(file: JetFile): List } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt index 42a5d6769e3..7e48e22b22e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt +++ b/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 { - 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() + + 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) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt index 080087ed088..74bf6bd9ac6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt +++ b/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, 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, - additionalScopes: List, - 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() - - 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) - } - } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt index e6a157b09c8..272ee60ff50 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt +++ b/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) : 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 collectFromImports( @@ -189,7 +192,7 @@ class LazyImportResolver( lookupMode: LookupMode, descriptorsSelector: (JetScope, Name) -> Collection ): Collection { - return resolveSession.getStorageManager().compute { + return storageManager.compute { var descriptors: Collection? = 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()) { 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() for (directive in importResolver.indexedImports.imports) { val importPath = directive.getImportPath() ?: continue