diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt index 6f1611f699f..91744cd345f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt @@ -27,21 +27,18 @@ import org.jetbrains.kotlin.resolve.calls.tasks.createSynthesizedInvokes import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType import org.jetbrains.kotlin.resolve.scopes.ImportingScope -import org.jetbrains.kotlin.resolve.scopes.KtScope import org.jetbrains.kotlin.resolve.scopes.LexicalChainedScope import org.jetbrains.kotlin.resolve.scopes.LexicalScope -import org.jetbrains.kotlin.resolve.scopes.utils.collectAllFromMeAndParent -import org.jetbrains.kotlin.resolve.scopes.utils.findLocalVariable +import org.jetbrains.kotlin.resolve.scopes.utils.* import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.util.OperatorNameConventions -import org.jetbrains.kotlin.utils.singletonOrEmptyList public interface CallableDescriptorCollector { public fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection - public fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection + public fun getNonExtensionsByName(scope: LexicalScope, name: Name, location: LookupLocation): Collection // todo this is hack for static members priority public fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection @@ -50,14 +47,13 @@ public interface CallableDescriptorCollector { public fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection - public fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection + public fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection } private fun CallableDescriptorCollector.withDefaultFilter() = filtered { !LibrarySourceHacks.shouldSkip(it) } private val FUNCTIONS_COLLECTOR = FunctionCollector.withDefaultFilter() private val VARIABLES_COLLECTOR = VariableCollector.withDefaultFilter() -private val PROPERTIES_COLLECTOR = PropertyCollector.withDefaultFilter() public class CallableDescriptorCollectors(val collectors: List>) : Iterable> { @@ -73,7 +69,6 @@ public class CallableDescriptorCollectors(val collectors public val FUNCTIONS: CallableDescriptorCollectors = CallableDescriptorCollectors(listOf(FUNCTIONS_COLLECTOR as CallableDescriptorCollector)) public val VARIABLES: CallableDescriptorCollectors = CallableDescriptorCollectors(listOf(VARIABLES_COLLECTOR)) - public val PROPERTIES: CallableDescriptorCollectors = CallableDescriptorCollectors(listOf(PROPERTIES_COLLECTOR)) } } @@ -104,14 +99,14 @@ private object FunctionCollector : CallableDescriptorCollector { - return scope.getFunctions(name, location).filter { it.extensionReceiverParameter == null } + getConstructors(scope, name, location) + override fun getNonExtensionsByName(scope: LexicalScope, name: Name, location: LookupLocation): Collection { + return scope.collectFunctions(name, location).filter { it.extensionReceiverParameter == null } + getConstructors(scope, name, location) } override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { val receiverScope = receiver.memberScope val members = receiverScope.getFunctions(name, location) - val constructors = getConstructors(receiverScope, name, location, { !isStaticNestedClass(it) }) + val constructors = getConstructors(receiverScope.memberScopeAsImportingScope(), name, location, { !isStaticNestedClass(it) }) if (name == OperatorNameConventions.INVOKE && KotlinBuiltIns.isExtensionFunctionType(receiver)) { // If we're looking for members of an extension function type, we ignore the non-extension "invoke"s @@ -127,13 +122,13 @@ private object FunctionCollector : CallableDescriptorCollector { - return getConstructors(receiver.memberScope, name, location, { isStaticNestedClass(it) }) + return getConstructors(receiver.memberScope.memberScopeAsImportingScope(), name, location, { isStaticNestedClass(it) }) } - override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { - val functions = scope.getFunctions(name, location) + override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { + val functions = scope.collectFunctions(name, location) val (extensions, nonExtensions) = functions.partition { it.extensionReceiverParameter != null } - val syntheticExtensions = scope.getSyntheticExtensionFunctions(receiverTypes, name, location) + val syntheticExtensions = scope.collectSyntheticExtensionFunctions(receiverTypes, name, location) if (name == OperatorNameConventions.INVOKE) { // Create synthesized "invoke" extensions for each non-extension "invoke" found in the scope @@ -144,11 +139,12 @@ private object FunctionCollector : CallableDescriptorCollector Boolean = { true } ): Collection { - val classifier = scope.getClassifier(name, location) + val classifier = scope.findClassifier(name, location) return getConstructors(classifier, filterClassPredicate) } @@ -183,19 +179,15 @@ private object VariableCollector : CallableDescriptorCollector { - val localVariable = scope.getLocalVariable(name) - if (localVariable != null) { - return setOf(localVariable) - } - val properties = scope.getProperties(name, location).filter { it.extensionReceiverParameter == null } + override fun getNonExtensionsByName(scope: LexicalScope, name: Name, location: LookupLocation): Collection { + val properties = scope.collectVariables(name, location).filter { it.extensionReceiverParameter == null } val fakeDescriptor = getFakeDescriptorForObject(scope, name, location) return if (fakeDescriptor != null) properties + fakeDescriptor else properties } @@ -203,7 +195,7 @@ private object VariableCollector : CallableDescriptorCollector { val memberScope = receiver.memberScope val properties = memberScope.getProperties(name, location) - val fakeDescriptor = getFakeDescriptorForObject(memberScope, name, location) + val fakeDescriptor = getFakeDescriptorForObject(memberScope.memberScopeAsImportingScope(), name, location) return if (fakeDescriptor != null) properties + fakeDescriptor else properties } @@ -211,47 +203,15 @@ private object VariableCollector : CallableDescriptorCollector, location: LookupLocation): Collection { + override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { // property may have an extension function type, we check the applicability later to avoid an early computing of deferred types - return scope.getLocalVariable(name).singletonOrEmptyList() + - scope.getProperties(name, location) + - scope.getSyntheticExtensionProperties(receiverTypes, name, location) + return scope.collectVariables(name, location) + + scope.collectSyntheticExtensionProperties(receiverTypes, name, location) } override fun toString() = "VARIABLES" } -private object PropertyCollector : CallableDescriptorCollector { - private fun filterProperties(variableDescriptors: Collection) = - variableDescriptors.filter { it is PropertyDescriptor } - - override fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - return filterProperties(VARIABLES_COLLECTOR.getLocalNonExtensionsByName(lexicalScope, name, location)) - } - - override fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - return filterProperties(VARIABLES_COLLECTOR.getStaticInheritanceByName(lexicalScope, name, location)) - } - - override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection { - return filterProperties(VARIABLES_COLLECTOR.getNonExtensionsByName(scope, name, location)) - } - - override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - return filterProperties(VARIABLES_COLLECTOR.getMembersByName(receiver, name, location)) - } - - override fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - return filterProperties(VARIABLES_COLLECTOR.getStaticMembersByName(receiver, name, location)) - } - - override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { - return filterProperties(VARIABLES_COLLECTOR.getExtensionsByName(scope, name, receiverTypes, location)) - } - - override fun toString() = "PROPERTIES" -} - private fun CallableDescriptorCollector.filtered(filter: (D) -> Boolean): CallableDescriptorCollector { val delegate = this return object : CallableDescriptorCollector { @@ -263,7 +223,7 @@ private fun CallableDescriptorCollector.filtered(fil return delegate.getStaticInheritanceByName(lexicalScope, name, location) } - override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection { + override fun getNonExtensionsByName(scope: LexicalScope, name: Name, location: LookupLocation): Collection { return delegate.getNonExtensionsByName(scope, name, location).filter(filter) } @@ -275,7 +235,7 @@ private fun CallableDescriptorCollector.filtered(fil return delegate.getStaticMembersByName(receiver, name, location).filter(filter) } - override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { + override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { return delegate.getExtensionsByName(scope, name, receiverTypes, location).filter(filter) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt index a37d3673390..1d3824a38d9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt @@ -40,7 +40,6 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.resolve.scopes.receivers.QualifierReceiver import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER -import org.jetbrains.kotlin.resolve.scopes.utils.asKtScope import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope import org.jetbrains.kotlin.resolve.validation.InfixValidator @@ -201,7 +200,7 @@ public class TaskPrioritizer( //extensions c.result.addCandidates { val extensions = callableDescriptorCollector.getExtensionsByName( - c.scope.asKtScope(), c.name, explicitReceiver.types, createLookupLocation(c)) + c.scope, c.name, explicitReceiver.types, createLookupLocation(c)) val filteredExtensions = if (filter == null) extensions else extensions.filter(filter) convertWithImpliedThis( @@ -261,7 +260,7 @@ public class TaskPrioritizer( val dynamicScope = dynamicCallableDescriptors.createDynamicDescriptorScope(c.context.call, c.scope.ownerDescriptor) val dynamicDescriptors = c.callableDescriptorCollectors.flatMap { - it.getNonExtensionsByName(dynamicScope, c.name, createLookupLocation(c)) + it.getNonExtensionsByName(dynamicScope.memberScopeAsImportingScope(), c.name, createLookupLocation(c)) } convertWithReceivers(dynamicDescriptors, explicitReceiver.value, NO_RECEIVER, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call) @@ -282,7 +281,7 @@ public class TaskPrioritizer( ) { c.result.addCandidates { val memberExtensions = - callableDescriptorCollector.getExtensionsByName(dispatchReceiver.type.memberScope, c.name, receiverParameter.types, createLookupLocation(c)) + callableDescriptorCollector.getExtensionsByName(dispatchReceiver.type.memberScope.memberScopeAsImportingScope(), c.name, receiverParameter.types, createLookupLocation(c)) convertWithReceivers(memberExtensions, dispatchReceiver, receiverParameter.value, receiverKind, c.context.call) } } @@ -322,7 +321,7 @@ public class TaskPrioritizer( //nonlocals c.callableDescriptorCollectors.forEach { c.result.addCandidates { - val descriptors = it.getNonExtensionsByName(c.scope.asKtScope(), c.name, lookupLocation) + val descriptors = it.getNonExtensionsByName(c.scope, c.name, lookupLocation) .filter { c.scope is ImportingScope || !ExpressionTypingUtils.isLocal(c.scope.ownerDescriptor, it) } convertWithImpliedThisAndNoReceiver(c.scope, descriptors, c.context.call) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt index 182af07daa7..eae59af6bf7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCol import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.resolve.scopes.KtScope import org.jetbrains.kotlin.resolve.scopes.KtScopeImpl +import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.Variance @@ -229,7 +230,7 @@ public fun DeclarationDescriptor.isDynamic(): Boolean { } class CollectorForDynamicReceivers(val delegate: CallableDescriptorCollector) : CallableDescriptorCollector by delegate { - override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { + override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { return delegate.getExtensionsByName(scope, name, receiverTypes, location).filter { it.getExtensionReceiverParameter()?.getType()?.isDynamic() ?: false } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt index d76030c574c..a99500ed848 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt @@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.scopes.receivers import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.Errors.* -import org.jetbrains.kotlin.incremental.components.NoLookupLocation +import org.jetbrains.kotlin.incremental.KotlinLookupLocation import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtExpression import org.jetbrains.kotlin.psi.KtSimpleNameExpression @@ -32,7 +32,9 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType import org.jetbrains.kotlin.resolve.scopes.ChainedScope import org.jetbrains.kotlin.resolve.scopes.FilteringScope import org.jetbrains.kotlin.resolve.scopes.KtScope -import org.jetbrains.kotlin.resolve.scopes.utils.asKtScope +import org.jetbrains.kotlin.resolve.scopes.utils.findClassifier +import org.jetbrains.kotlin.resolve.scopes.utils.findPackage +import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext @@ -147,14 +149,14 @@ fun createQualifier( context: ExpressionTypingContext ): QualifierReceiver? { val receiverScope = when { - !receiver.exists() -> context.scope.asKtScope() - receiver is QualifierReceiver -> receiver.scope - else -> receiver.getType().getMemberScope() + !receiver.exists() -> context.scope + receiver is QualifierReceiver -> receiver.scope.memberScopeAsImportingScope() + else -> receiver.getType().getMemberScope().memberScopeAsImportingScope() } val name = expression.getReferencedNameAsName() - val packageViewDescriptor = receiverScope.getPackage(name) - val classifierDescriptor = receiverScope.getClassifier(name, NoLookupLocation.WHEN_TYPING) + val packageViewDescriptor = receiverScope.findPackage(name) + val classifierDescriptor = receiverScope.findClassifier(name, KotlinLookupLocation(expression)) if (packageViewDescriptor == null && classifierDescriptor == null) return null diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt index 1de8eaa5711..c641f166319 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt @@ -82,8 +82,6 @@ public fun LexicalScope.findLocalVariable(name: Name): VariableDescriptor? { when { it is LexicalScopeWrapper -> it.delegate.findLocalVariable(name) - it is MemberScopeToImportingScopeAdapter -> it.memberScope.getLocalVariable(name) /* todo remove hack*/ - it !is ImportingScope && it !is LexicalChainedScope -> it.getContributedVariables(name, NoLookupLocation.WHEN_GET_LOCAL_VARIABLE).singleOrNull() /* todo check this*/ else -> null @@ -131,72 +129,9 @@ public fun LexicalScope.collectSyntheticExtensionFunctions(receiverTypes: Collec public fun LexicalScope.takeSnapshot(): LexicalScope = if (this is LexicalWritableScope) takeSnapshot() else this -@Deprecated("Will be removed soon") -public fun LexicalScope.asKtScope(): KtScope { - if (this is KtScope) return this - if (this is MemberScopeToImportingScopeAdapter) return this.memberScope - return LexicalToKtScopeAdapter(this) -} - @JvmOverloads public fun KtScope.memberScopeAsImportingScope(parentScope: ImportingScope? = null): ImportingScope = MemberScopeToImportingScopeAdapter(parentScope, this) -private class LexicalToKtScopeAdapter(lexicalScope: LexicalScope): KtScope { - val lexicalScope = lexicalScope.takeSnapshot() - - override fun getClassifier(name: Name, location: LookupLocation) = lexicalScope.findClassifier(name, location) - - override fun getPackage(name: Name) = lexicalScope.findPackage(name) - - override fun getProperties(name: Name, location: LookupLocation): Collection { - return lexicalScope.collectAllFromImportingScopes { it.getContributedVariables(name, location) } - } - - override fun getFunctions(name: Name, location: LookupLocation) - = lexicalScope.collectFunctions(name, location) - - override fun getLocalVariable(name: Name) = lexicalScope.findLocalVariable(name) - - override fun getSyntheticExtensionProperties(receiverTypes: Collection, name: Name, location: LookupLocation) - = lexicalScope.collectSyntheticExtensionProperties(receiverTypes, name, location) - - override fun getSyntheticExtensionFunctions(receiverTypes: Collection, name: Name, location: LookupLocation) - = lexicalScope.collectSyntheticExtensionFunctions(receiverTypes, name, location) - - override fun getSyntheticExtensionProperties(receiverTypes: Collection) - = lexicalScope.collectSyntheticExtensionProperties(receiverTypes) - - override fun getSyntheticExtensionFunctions(receiverTypes: Collection) - = lexicalScope.collectSyntheticExtensionFunctions(receiverTypes) - - override fun getContainingDeclaration() = lexicalScope.ownerDescriptor - - override fun getDeclarationsByLabel(labelName: Name) = lexicalScope.getDeclarationsByLabel(labelName) - - override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection { - return lexicalScope.collectAllFromMeAndParent { it.getContributedDescriptors(kindFilter, nameFilter) } - } - - override fun getImplicitReceiversHierarchy() = lexicalScope.getImplicitReceiversHierarchy() - override fun getOwnDeclaredDescriptors() = lexicalScope.getContributedDescriptors() - - override fun equals(other: Any?) = other is LexicalToKtScopeAdapter && other.lexicalScope == this.lexicalScope - - override fun hashCode() = lexicalScope.hashCode() - - override fun toString() = "LexicalToKtScopeAdapter for $lexicalScope" - - override fun printScopeStructure(p: Printer) { - p.println(javaClass.simpleName) - p.pushIndent() - - lexicalScope.printStructure(p) - - p.popIndent() - p.println("}") - } -} - private class MemberScopeToImportingScopeAdapter(override val parent: ImportingScope?, val memberScope: KtScope) : ImportingScope { override fun getContributedPackage(name: Name): PackageViewDescriptor? = memberScope.getPackage(name)