From 8fc00634102b874256404b6ee4fe015e2edbfd16 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Wed, 14 Jan 2015 18:02:37 +0300 Subject: [PATCH] Refactoring of Importer - PlatformToKotlinClassMap is the same for all imports --- .../org/jetbrains/kotlin/resolve/Importer.kt | 34 +++++++++++-------- .../kotlin/resolve/ImportsResolver.java | 6 ++-- .../resolve/QualifiedExpressionResolver.java | 3 +- .../kotlin/resolve/lazy/LazyImportScope.kt | 4 +-- .../kotlin/idea/caches/KotlinIndicesHelper.kt | 15 ++++---- 5 files changed, 33 insertions(+), 29 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/Importer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/Importer.kt index 3e11dc2ee8c..5241bdeb2cb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/Importer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/Importer.kt @@ -25,14 +25,16 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScope import java.util.ArrayList public trait Importer { - public fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) - + public fun addAllUnderImport(descriptor: DeclarationDescriptor) public fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) - public open class StandardImporter(private val fileScope: WritableScope) : Importer { + public open class StandardImporter( + private val fileScope: WritableScope, + private val platformToKotlinClassMap: PlatformToKotlinClassMap + ) : Importer { - override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) { - importAllUnderDeclaration(descriptor, platformToKotlinClassMap) + override fun addAllUnderImport(descriptor: DeclarationDescriptor) { + importAllUnderDeclaration(descriptor) } override fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) { @@ -49,7 +51,7 @@ public trait Importer { } } - protected fun importAllUnderDeclaration(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) { + protected fun importAllUnderDeclaration(descriptor: DeclarationDescriptor) { if (descriptor is PackageViewDescriptor) { val scope = NoSubpackagesInPackageScope(descriptor) fileScope.importScope(createFilteringScope(scope, descriptor, platformToKotlinClassMap)) @@ -71,17 +73,21 @@ public trait Importer { } } - public class DelayedImporter(fileScope: WritableScope) : StandardImporter(fileScope) { + public class DelayedImporter( + fileScope: WritableScope, + platformToKotlinClassMap: PlatformToKotlinClassMap + ) : StandardImporter(fileScope, platformToKotlinClassMap) { + private trait DelayedImportEntry - private class AllUnderImportEntry(val first: DeclarationDescriptor, val second: PlatformToKotlinClassMap) : DelayedImportEntry + private class AllUnderImportEntry(val descriptor: DeclarationDescriptor) : DelayedImportEntry - private class AliasImportEntry(val first: DeclarationDescriptor, val second: Name) : DelayedImportEntry + private class AliasImportEntry(val descriptor: DeclarationDescriptor, val name: Name) : DelayedImportEntry private val imports = ArrayList() - override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) { - imports.add(AllUnderImportEntry(descriptor, platformToKotlinClassMap)) + override fun addAllUnderImport(descriptor: DeclarationDescriptor) { + imports.add(AllUnderImportEntry(descriptor)) } override fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) { @@ -91,18 +97,18 @@ public trait Importer { public fun processImports() { for (anImport in imports) { if (anImport is AllUnderImportEntry) { - importAllUnderDeclaration(anImport.first, anImport.second) + importAllUnderDeclaration(anImport.descriptor) } else { anImport as AliasImportEntry - importDeclarationAlias(anImport.first, anImport.second) + importDeclarationAlias(anImport.descriptor, anImport.name) } } } } object DoNothingImporter : Importer { - override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) { + override fun addAllUnderImport(descriptor: DeclarationDescriptor) { } override fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ImportsResolver.java index 1a486c24768..160a031d0e0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ImportsResolver.java @@ -99,7 +99,7 @@ public class ImportsResolver { ) { @NotNull JetScope rootScope = JetModuleUtil.getSubpackagesOfRootScope(module); - Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(fileScope); + Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(fileScope, module.getPlatformToKotlinClassMap()); if (lookupMode == LookupMode.EVERYTHING) { fileScope.clearImports(); } @@ -110,7 +110,7 @@ public class ImportsResolver { JetImportDirective defaultImportDirective = importsFactory.createImportDirective(defaultImportPath); qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, fileScope, delayedImporter, - temporaryTrace, module, lookupMode); + temporaryTrace, lookupMode); } Map> resolvedDirectives = Maps.newHashMap(); @@ -120,7 +120,7 @@ public class ImportsResolver { for (JetImportDirective importDirective : importDirectives) { Collection descriptors = qualifiedExpressionResolver.processImportReference(importDirective, rootScopeForFile, fileScope, delayedImporter, - trace, module, lookupMode); + trace, lookupMode); if (!descriptors.isEmpty()) { resolvedDirectives.put(importDirective, descriptors); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java index 92727724971..0948d505413 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java @@ -60,7 +60,6 @@ public class QualifiedExpressionResolver { @NotNull JetScope scopeToCheckVisibility, @NotNull Importer importer, @NotNull BindingTrace trace, - @NotNull ModuleDescriptor module, @NotNull LookupMode lookupMode ) { if (importDirective.isAbsoluteInRootPackage()) { @@ -93,7 +92,7 @@ public class QualifiedExpressionResolver { } for (DeclarationDescriptor descriptor : descriptors) { - importer.addAllUnderImport(descriptor, module.getPlatformToKotlinClassMap()); + importer.addAllUnderImport(descriptor); } return Collections.emptyList(); } 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 afd6e969ce6..24e73ab2577 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt @@ -69,14 +69,14 @@ public class LazyImportScope(private val resolveSession: ResolveSession, val directiveImportScope = WritableScopeImpl(JetScope.Empty, containingDeclaration, RedeclarationHandler.DO_NOTHING, "Scope for import '" + directive.getDebugText() + "' resolve in " + toString()) directiveImportScope.changeLockLevel(WritableScope.LockLevel.BOTH) - val importer = Importer.StandardImporter(directiveImportScope) + val importer = Importer.StandardImporter(directiveImportScope, resolveSession.getModuleDescriptor().platformToKotlinClassMap) directiveUnderResolve = directive val descriptors: Collection try { val resolver = resolveSession.getQualifiedExpressionResolver() descriptors = resolver.processImportReference(directive, rootScope, containingDeclaration.getMemberScope(), - importer, traceForImportResolve, resolveSession.getModuleDescriptor(), mode) + importer, traceForImportResolve, mode) if (mode == LookupMode.EVERYTHING) { ImportsResolver.checkPlatformTypesMappedToKotlin(containingDeclaration.getModule(), traceForImportResolve, directive, descriptors) } diff --git a/idea/src/org/jetbrains/kotlin/idea/caches/KotlinIndicesHelper.kt b/idea/src/org/jetbrains/kotlin/idea/caches/KotlinIndicesHelper.kt index f47c1ae3cf8..ce840e48294 100644 --- a/idea/src/org/jetbrains/kotlin/idea/caches/KotlinIndicesHelper.kt +++ b/idea/src/org/jetbrains/kotlin/idea/caches/KotlinIndicesHelper.kt @@ -56,7 +56,7 @@ public class KotlinIndicesHelper( return declarations.flatMap { if (it.getContainingJetFile().isCompiled()) { val importDirective = JetPsiFactory(project).createImportDirective(it.getFqName().asString()) - analyzeImportReference(importDirective, resolutionScope, BindingTraceContext(), moduleDescriptor).filterIsInstance() + analyzeImportReference(importDirective, resolutionScope, BindingTraceContext()).filterIsInstance() } else { (resolutionFacade.resolveToDescriptor(it) as? CallableDescriptor).singletonOrEmptyList() @@ -118,7 +118,7 @@ public class KotlinIndicesHelper( val receiverValue = ExpressionReceiver(receiverExpression, expressionType) matchingNames.flatMapTo(this) { - findSuitableExtensions(it, index, receiverValue, dataFlowInfo, callType, resolutionScope, moduleDescriptor, bindingContext) + findSuitableExtensions(it, index, receiverValue, dataFlowInfo, callType, resolutionScope, bindingContext) } } else { @@ -126,7 +126,7 @@ public class KotlinIndicesHelper( for (receiver in resolutionScope.getImplicitReceiversWithInstance()) { matchingNames.flatMapTo(this) { - findSuitableExtensions(it, index, receiver.getValue(), dataFlowInfo, CallType.NORMAL, resolutionScope, moduleDescriptor, bindingContext) + findSuitableExtensions(it, index, receiver.getValue(), dataFlowInfo, CallType.NORMAL, resolutionScope, bindingContext) } } } @@ -141,13 +141,12 @@ public class KotlinIndicesHelper( dataFlowInfo: DataFlowInfo, callType: CallType, resolutionScope: JetScope, - module: ModuleDescriptor, bindingContext: BindingContext): Stream { val fqnString = callableFQN.asString() val extensions = index.get(fqnString, project, scope).filter { it.getReceiverTypeReference() != null } val descriptors = if (extensions.any { it.getContainingJetFile().isCompiled() } ) { val importDirective = JetPsiFactory(project).createImportDirective(fqnString) - analyzeImportReference(importDirective, resolutionScope, BindingTraceContext(), module) + analyzeImportReference(importDirective, resolutionScope, BindingTraceContext()) .filterIsInstance() .filter { it.getExtensionReceiverParameter() != null } } @@ -180,14 +179,14 @@ public class KotlinIndicesHelper( private fun findTopLevelCallables(fqName: FqName, context: JetExpression, jetScope: JetScope): Collection { val importDirective = JetPsiFactory(context.getProject()).createImportDirective(ImportPath(fqName, false)) - val allDescriptors = analyzeImportReference(importDirective, jetScope, BindingTraceContext(), moduleDescriptor) + val allDescriptors = analyzeImportReference(importDirective, jetScope, BindingTraceContext()) return allDescriptors.filterIsInstance().filter { it.getExtensionReceiverParameter() == null } } private fun analyzeImportReference( - importDirective: JetImportDirective, scope: JetScope, trace: BindingTrace, module: ModuleDescriptor + importDirective: JetImportDirective, scope: JetScope, trace: BindingTrace ): Collection { return QualifiedExpressionResolver().processImportReference(importDirective, scope, scope, Importer.DoNothingImporter, trace, - module, LookupMode.EVERYTHING) + LookupMode.EVERYTHING) } }