From 4e7718bfff3830a192db0bdf167b93392eb1c951 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Thu, 19 Jul 2018 17:28:50 +0300 Subject: [PATCH] Minor. Extract many properties to ImportResolutionComponents --- .../kotlin/resolve/lazy/FileScopeFactory.kt | 25 +++---- .../kotlin/resolve/lazy/LazyImportScope.kt | 66 ++++++++----------- 2 files changed, 37 insertions(+), 54 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt index 5c309e50d0b..9b026787e00 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt @@ -38,17 +38,12 @@ data class FileScopes(val lexicalScope: LexicalScope, val importingScope: Import class FileScopeFactory( private val topLevelDescriptorProvider: TopLevelDescriptorProvider, - private val storageManager: StorageManager, - private val moduleDescriptor: ModuleDescriptor, - private val qualifiedExpressionResolver: QualifiedExpressionResolver, private val bindingTrace: BindingTrace, - private val platformToKotlinClassMap: PlatformToKotlinClassMap, private val targetPlatform: TargetPlatform, - private val languageVersionSettings: LanguageVersionSettings, - private val deprecationResolver: DeprecationResolver + private val components: ImportResolutionComponents ) { private val defaultImports = - targetPlatform.getDefaultImports(languageVersionSettings, includeLowPriorityImports = false).map(::DefaultImportImpl) + targetPlatform.getDefaultImports(components.languageVersionSettings, includeLowPriorityImports = false).map(::DefaultImportImpl) private val defaultLowPriorityImports = targetPlatform.defaultLowPriorityImports.map(::DefaultImportImpl) @@ -63,7 +58,7 @@ class FileScopeFactory( } fun createScopesForFile(file: KtFile, existingImports: ImportingScope? = null): FileScopes { - val packageView = moduleDescriptor.getPackage(file.packageFqName) + val packageView = components.moduleDescriptor.getPackage(file.packageFqName) val packageFragment = topLevelDescriptorProvider.getPackageFragmentOrDiagnoseFailure(file.packageFqName, file) return FilesScopesBuilder(file, existingImports, packageFragment, packageView).result @@ -113,7 +108,7 @@ class FileScopeFactory( return DefaultImportResolvers(explicit, allUnder, lowPriority) } - private val defaultImportResolvers by storageManager.createLazyValue { + private val defaultImportResolvers by components.storageManager.createLazyValue { createDefaultImportResolvers(emptyList(), emptyList()) } @@ -124,9 +119,7 @@ class FileScopeFactory( packageFragment: PackageFragmentDescriptor?, excludedImports: List? = null ) = LazyImportResolver( - storageManager, qualifiedExpressionResolver, moduleDescriptor, platformToKotlinClassMap, languageVersionSettings, - indexedImports, aliasImportNames concat excludedImports, trace, packageFragment, - deprecationResolver + components, indexedImports, aliasImportNames concat excludedImports, trace, packageFragment ) private fun createImportResolver( @@ -136,9 +129,7 @@ class FileScopeFactory( packageFragment: PackageFragmentDescriptor?, excludedImports: List? = null ) = LazyImportResolverForKtImportDirective( - storageManager, qualifiedExpressionResolver, moduleDescriptor, platformToKotlinClassMap, languageVersionSettings, - indexedImports, aliasImportNames concat excludedImports, trace, packageFragment, - deprecationResolver + components, indexedImports, aliasImportNames concat excludedImports, trace, packageFragment ) private inner class FilesScopesBuilder( @@ -160,7 +151,7 @@ class FileScopeFactory( val lazyImportingScope = object : ImportingScope by ImportingScope.Empty { // avoid constructing the scope before we query it - override val parent: ImportingScope by storageManager.createLazyValue { + override val parent: ImportingScope by components.storageManager.createLazyValue { createImportingScope() } } @@ -236,7 +227,7 @@ class FileScopeFactory( "Default explicit imports in $debugName" ) - scope = SubpackagesImportingScope(scope, moduleDescriptor, FqName.ROOT) + scope = SubpackagesImportingScope(scope, components.moduleDescriptor, FqName.ROOT) scope = currentPackageScope(packageView, aliasImportNames, dummyContainerDescriptor, FilteringKind.VISIBLE_CLASSES, scope) 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 36bc608d8a0..a930567ee5c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt @@ -73,22 +73,28 @@ interface ImportForceResolver { fun forceResolveImport(importDirective: KtImportDirective) } -open class LazyImportResolver( +class ImportResolutionComponents( val storageManager: StorageManager, - private val qualifiedExpressionResolver: QualifiedExpressionResolver, + val qualifiedExpressionResolver: QualifiedExpressionResolver, val moduleDescriptor: ModuleDescriptor, - private val platformToKotlinClassMap: PlatformToKotlinClassMap, + val platformToKotlinClassMap: PlatformToKotlinClassMap, val languageVersionSettings: LanguageVersionSettings, - val indexedImports: IndexedImports, - excludedImportNames: Collection, - protected val traceForImportResolve: BindingTrace, - private val packageFragment: PackageFragmentDescriptor?, val deprecationResolver: DeprecationResolver +) + +open class LazyImportResolver( + internal val components: ImportResolutionComponents, + val indexedImports: IndexedImports, + val excludedImportNames: Collection, + val traceForImportResolve: BindingTrace, + val packageFragment: PackageFragmentDescriptor? ) { - private val importedScopesProvider = storageManager.createMemoizedFunctionWithNullableValues { directive: KtImportInfo -> - qualifiedExpressionResolver.processImportReference( - directive, moduleDescriptor, traceForImportResolve, excludedImportNames, packageFragment - ) + private val importedScopesProvider = with(components) { + storageManager.createMemoizedFunctionWithNullableValues { directive: KtImportInfo -> + qualifiedExpressionResolver.processImportReference( + directive, moduleDescriptor, traceForImportResolve, excludedImportNames, packageFragment + ) + } } fun selectSingleFromImports( @@ -106,14 +112,14 @@ open class LazyImportResolver( } return target } - return storageManager.compute(::compute) + return components.storageManager.compute(::compute) } fun collectFromImports( name: Name, descriptorsSelector: (ImportingScope, Name) -> Collection ): Collection { - return storageManager.compute { + return components.storageManager.compute { var descriptors: Collection? = null for (directive in indexedImports.importsForName(name)) { val descriptorsForImport = descriptorsSelector(getImportScope(directive), name) @@ -143,42 +149,28 @@ open class LazyImportResolver( } class LazyImportResolverForKtImportDirective( - storageManager: StorageManager, - qualifiedExpressionResolver: QualifiedExpressionResolver, - moduleDescriptor: ModuleDescriptor, - platformToKotlinClassMap: PlatformToKotlinClassMap, - languageVersionSettings: LanguageVersionSettings, + components: ImportResolutionComponents, indexedImports: IndexedImports, excludedImportNames: Collection, traceForImportResolve: BindingTrace, - packageFragment: PackageFragmentDescriptor?, - deprecationResolver: DeprecationResolver + packageFragment: PackageFragmentDescriptor? ) : LazyImportResolver( - storageManager, - qualifiedExpressionResolver, - moduleDescriptor, - platformToKotlinClassMap, - languageVersionSettings, - indexedImports, - excludedImportNames, - traceForImportResolve, - packageFragment, - deprecationResolver + components, indexedImports, excludedImportNames, traceForImportResolve, packageFragment ), ImportForceResolver { - private val forceResolveImportDirective = storageManager.createMemoizedFunction { directive: KtImportDirective -> + private val forceResolveImportDirective = components.storageManager.createMemoizedFunction { directive: KtImportDirective -> val scope = getImportScope(directive) if (scope is LazyExplicitImportScope) { val allDescriptors = scope.storeReferencesToDescriptors() PlatformClassesMappedToKotlinChecker.checkPlatformClassesMappedToKotlin( - platformToKotlinClassMap, traceForImportResolve, directive, allDescriptors + components.platformToKotlinClassMap, traceForImportResolve, directive, allDescriptors ) } Unit } - private val forceResolveNonDefaultImportsTask: NotNullLazyValue = storageManager.createLazyValue { + private val forceResolveNonDefaultImportsTask: NotNullLazyValue = components.storageManager.createLazyValue { val explicitClassImports = HashMultimap.create() for (importInfo in indexedImports.imports) { forceResolveImport(importInfo) @@ -249,12 +241,12 @@ class LazyImportScope( private fun LazyImportResolver<*>.isClassifierVisible(descriptor: ClassifierDescriptor): Boolean { if (filteringKind == FilteringKind.ALL) return true - if (deprecationResolver.isHiddenInResolution(descriptor)) return false + if (components.deprecationResolver.isHiddenInResolution(descriptor)) return false val visibility = (descriptor as DeclarationDescriptorWithVisibility).visibility val includeVisible = filteringKind == FilteringKind.VISIBLE_CLASSES if (!visibility.mustCheckInImports()) return includeVisible - return Visibilities.isVisibleIgnoringReceiver(descriptor, moduleDescriptor) == includeVisible + return Visibilities.isVisibleIgnoringReceiver(descriptor, components.moduleDescriptor) == includeVisible } override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? { @@ -295,9 +287,9 @@ 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() - val storageManager = importResolver.storageManager + val storageManager = importResolver.components.storageManager if (secondaryImportResolver != null) { - assert(storageManager === secondaryImportResolver.storageManager) { "Multiple storage managers are not supported" } + assert(storageManager === secondaryImportResolver.components.storageManager) { "Multiple storage managers are not supported" } } return storageManager.compute {