azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Minor. Removed util method LexicalScope.asKtScope()

Browse Source
This commit is contained in:
Stanislav Erokhin
2015-10-31 08:53:52 +03:00
parent 40146a0df8
commit 711daa459a
5 changed files with 38 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt
+23 -63
View File
@@ -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<D : CallableDescriptor> {
public fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection<D>
public fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<D>
public fun getNonExtensionsByName(scope: LexicalScope, name: Name, location: LookupLocation): Collection<D>
// todo this is hack for static members priority
public fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection<D>
@@ -50,14 +47,13 @@ public interface CallableDescriptorCollector<D : CallableDescriptor> {
public fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection<D>
public fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<D>
public fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<D>
}
private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.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<D : CallableDescriptor>(val collectors: List<CallableDescriptorCollector<D>>) :
Iterable<CallableDescriptorCollector<D>> {
@@ -73,7 +69,6 @@ public class CallableDescriptorCollectors<D : CallableDescriptor>(val collectors
public val FUNCTIONS: CallableDescriptorCollectors<CallableDescriptor> =
CallableDescriptorCollectors(listOf(FUNCTIONS_COLLECTOR as CallableDescriptorCollector<CallableDescriptor>))
public val VARIABLES: CallableDescriptorCollectors<VariableDescriptor> = CallableDescriptorCollectors(listOf(VARIABLES_COLLECTOR))
public val PROPERTIES: CallableDescriptorCollectors<VariableDescriptor> = CallableDescriptorCollectors(listOf(PROPERTIES_COLLECTOR))
}
}
@@ -104,14 +99,14 @@ private object FunctionCollector : CallableDescriptorCollector<FunctionDescripto
}
}
override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
return scope.getFunctions(name, location).filter { it.extensionReceiverParameter == null } + getConstructors(scope, name, location)
override fun getNonExtensionsByName(scope: LexicalScope, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
return scope.collectFunctions(name, location).filter { it.extensionReceiverParameter == null } + getConstructors(scope, name, location)
}
override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
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<FunctionDescripto
}
override fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
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<KotlinType>, location: LookupLocation): Collection<FunctionDescriptor> {
val functions = scope.getFunctions(name, location)
override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<FunctionDescriptor> {
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<FunctionDescripto
}
private fun getConstructors(
scope: KtScope, name: Name,
scope: LexicalScope,
name: Name,
location: LookupLocation,
filterClassPredicate: (ClassDescriptor) -> Boolean = { true }
): Collection<FunctionDescriptor> {
val classifier = scope.getClassifier(name, location)
val classifier = scope.findClassifier(name, location)
return getConstructors(classifier, filterClassPredicate)
}
@@ -183,19 +179,15 @@ private object VariableCollector : CallableDescriptorCollector<VariableDescripto
}
}
private fun getFakeDescriptorForObject(scope: KtScope, name: Name, location: LookupLocation): VariableDescriptor? {
val classifier = scope.getClassifier(name, location)
private fun getFakeDescriptorForObject(scope: LexicalScope, name: Name, location: LookupLocation): VariableDescriptor? {
val classifier = scope.findClassifier(name, location)
if (classifier !is ClassDescriptor || !classifier.hasClassObjectType) return null
return FakeCallableDescriptorForObject(classifier)
}
override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
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<VariableDescriptor> {
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<VariableDescripto
override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
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<VariableDescripto
return listOf()
}
override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<VariableDescriptor> {
override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<VariableDescriptor> {
// 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<VariableDescriptor> {
private fun filterProperties(variableDescriptors: Collection<VariableDescriptor>) =
variableDescriptors.filter { it is PropertyDescriptor }
override fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
return filterProperties(VARIABLES_COLLECTOR.getLocalNonExtensionsByName(lexicalScope, name, location))
}
override fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
return filterProperties(VARIABLES_COLLECTOR.getStaticInheritanceByName(lexicalScope, name, location))
}
override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
return filterProperties(VARIABLES_COLLECTOR.getNonExtensionsByName(scope, name, location))
}
override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
return filterProperties(VARIABLES_COLLECTOR.getMembersByName(receiver, name, location))
}
override fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection<VariableDescriptor> {
return filterProperties(VARIABLES_COLLECTOR.getStaticMembersByName(receiver, name, location))
}
override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<VariableDescriptor> {
return filterProperties(VARIABLES_COLLECTOR.getExtensionsByName(scope, name, receiverTypes, location))
}
override fun toString() = "PROPERTIES"
}
private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.filtered(filter: (D) -> Boolean): CallableDescriptorCollector<D> {
val delegate = this
return object : CallableDescriptorCollector<D> {
@@ -263,7 +223,7 @@ private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.filtered(fil
return delegate.getStaticInheritanceByName(lexicalScope, name, location)
}
override fun getNonExtensionsByName(scope: KtScope, name: Name, location: LookupLocation): Collection<D> {
override fun getNonExtensionsByName(scope: LexicalScope, name: Name, location: LookupLocation): Collection<D> {
return delegate.getNonExtensionsByName(scope, name, location).filter(filter)
}
@@ -275,7 +235,7 @@ private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.filtered(fil
return delegate.getStaticMembersByName(receiver, name, location).filter(filter)
}
override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<D> {
override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<D> {
return delegate.getExtensionsByName(scope, name, receiverTypes, location).filter(filter)
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
+4 -5
View File
@@ -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)
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
+2 -1
View File
@@ -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<D: CallableDescriptor>(val delegate: CallableDescriptorCollector<D>) : CallableDescriptorCollector<D> by delegate {
override fun getExtensionsByName(scope: KtScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<D> {
override fun getExtensionsByName(scope: LexicalScope, name: Name, receiverTypes: Collection<KotlinType>, location: LookupLocation): Collection<D> {
return delegate.getExtensionsByName(scope, name, receiverTypes, location).filter {
it.getExtensionReceiverParameter()?.getType()?.isDynamic() ?: false
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt
+9 -7
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt
-65
View File
@@ -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<VariableDescriptor> {
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<KotlinType>, name: Name, location: LookupLocation)
= lexicalScope.collectSyntheticExtensionProperties(receiverTypes, name, location)
override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KotlinType>, name: Name, location: LookupLocation)
= lexicalScope.collectSyntheticExtensionFunctions(receiverTypes, name, location)
override fun getSyntheticExtensionProperties(receiverTypes: Collection<KotlinType>)
= lexicalScope.collectSyntheticExtensionProperties(receiverTypes)
override fun getSyntheticExtensionFunctions(receiverTypes: Collection<KotlinType>)
= 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<DeclarationDescriptor> {
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)