From 02d7cf96148ed7f0481fe8c1bb1f77ac0b593cf9 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Tue, 6 Sep 2016 16:15:43 +0300 Subject: [PATCH] Minor. Rename get*Names -> compute*Names To indicate that repeating calls to them may require additional computations Also change second parameter to be nullable, this will be necessary in the next commits --- .../lazy/descriptors/LazyJavaClassMemberScope.kt | 10 +++++----- .../java/lazy/descriptors/LazyJavaPackageScope.kt | 13 +++++++------ .../load/java/lazy/descriptors/LazyJavaScope.kt | 15 ++++++++------- .../lazy/descriptors/LazyJavaStaticClassScope.kt | 10 +++++----- 4 files changed, 25 insertions(+), 23 deletions(-) diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt index 8aaa5f1954f..ebe8bbe62af 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -71,7 +71,7 @@ class LazyJavaClassMemberScope( return object : ClassMemberIndex(jClass, { !it.isStatic }) { // For SAM-constructors override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection - = super.getMethodNames(nameFilter) + getClassNames(DescriptorKindFilter.CLASSIFIERS, nameFilter) + = super.getMethodNames(nameFilter) + computeClassNames(DescriptorKindFilter.CLASSIFIERS, nameFilter) } } @@ -660,15 +660,15 @@ class LazyJavaClassMemberScope( return super.getContributedVariables(name, location) } - override fun getClassNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection + override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection = nestedClassIndex().keys + enumEntryIndex().keys - override fun getPropertyNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection { - if (jClass.isAnnotationType) return memberIndex().getMethodNames(nameFilter) + override fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection { + if (jClass.isAnnotationType) return memberIndex().getMethodNames(nameFilter ?: alwaysTrue()) return memberIndex().getAllFieldNames() + ownerDescriptor.getTypeConstructor().getSupertypes().flatMapTo(LinkedHashSet()) { supertype -> - supertype.memberScope.getContributedDescriptors(kindFilter, nameFilter).map { variable -> + supertype.memberScope.getContributedDescriptors(kindFilter, nameFilter ?: alwaysTrue()).map { variable -> variable.getName() } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt index 2c51467d299..5e12ef9bedb 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt @@ -34,6 +34,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.storage.NullableLazyValue +import org.jetbrains.kotlin.utils.alwaysTrue class LazyJavaPackageScope( c: LazyJavaResolverContext, @@ -134,23 +135,23 @@ class LazyJavaPackageScope( override fun computeMemberIndex(): MemberIndex = object : MemberIndex by EMPTY_MEMBER_INDEX { // For SAM-constructors - override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection = getClassNames(DescriptorKindFilter.CLASSIFIERS, nameFilter) + override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection = computeClassNames(DescriptorKindFilter.CLASSIFIERS, nameFilter) } - override fun getClassNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection { + override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection { // neither objects nor enum members can be in java package if (!kindFilter.acceptsKinds(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS_MASK)) return listOf() - return jPackage.getClasses(nameFilter).mapNotNull { klass -> + return jPackage.getClasses(nameFilter ?: alwaysTrue()).mapNotNull { klass -> if (klass.lightClassOriginKind == LightClassOriginKind.SOURCE) null else klass.name } } - override fun getFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection { + override fun computeFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection { // optimization: only SAM-constructors may exist in java package if (kindFilter.excludes.contains(SamConstructorDescriptorKindExclude)) return listOf() - return super.getFunctionNames(kindFilter, nameFilter) + return super.computeFunctionNames(kindFilter, nameFilter) } override fun computeNonDeclaredFunctions(result: MutableCollection, name: Name) { @@ -159,7 +160,7 @@ class LazyJavaPackageScope( }?.let { result.add(it) } } - override fun getPropertyNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean) = listOf() + override fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?) = listOf() // we don't use implementation from super which caches all descriptors and does not use filters override fun getContributedDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt index b1cee0a4db1..7481f2ea7e7 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt @@ -45,6 +45,7 @@ import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.utils.Printer import org.jetbrains.kotlin.utils.addIfNotNull +import org.jetbrains.kotlin.utils.alwaysTrue import org.jetbrains.kotlin.utils.toReadOnlyList import java.util.* @@ -216,12 +217,12 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS override fun getContributedFunctions(name: Name, location: LookupLocation): Collection = functions(name) - protected open fun getFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection - = memberIndex().getMethodNames(nameFilter) + protected open fun computeFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection + = memberIndex().getMethodNames(nameFilter ?: alwaysTrue()) protected abstract fun computeNonDeclaredProperties(name: Name, result: MutableCollection) - protected abstract fun getPropertyNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection + protected abstract fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection private val properties = c.storageManager.createMemoizedFunction { name: Name -> @@ -300,7 +301,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS val result = LinkedHashSet() if (kindFilter.acceptsKinds(DescriptorKindFilter.CLASSIFIERS_MASK)) { - for (name in getClassNames(kindFilter, nameFilter)) { + for (name in computeClassNames(kindFilter, nameFilter)) { if (nameFilter(name)) { // Null signifies that a class found in Java is not present in Kotlin (e.g. package class) result.addIfNotNull(getContributedClassifier(name, location)) @@ -309,7 +310,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS } if (kindFilter.acceptsKinds(DescriptorKindFilter.FUNCTIONS_MASK) && !kindFilter.excludes.contains(NonExtensions)) { - for (name in getFunctionNames(kindFilter, nameFilter)) { + for (name in computeFunctionNames(kindFilter, nameFilter)) { if (nameFilter(name)) { result.addAll(getContributedFunctions(name, location)) } @@ -317,7 +318,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS } if (kindFilter.acceptsKinds(DescriptorKindFilter.VARIABLES_MASK) && !kindFilter.excludes.contains(NonExtensions)) { - for (name in getPropertyNames(kindFilter, nameFilter)) { + for (name in computePropertyNames(kindFilter, nameFilter)) { if (nameFilter(name)) { result.addAll(getContributedVariables(name, location)) } @@ -327,7 +328,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS return result.toReadOnlyList() } - protected abstract fun getClassNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection + protected abstract fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection override fun toString() = "Lazy scope for $ownerDescriptor" diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt index 4f261283161..150969c8265 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt @@ -51,17 +51,17 @@ class LazyJavaStaticClassScope( } } - override fun getFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection { + override fun computeFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection { if (jClass.isEnum) { - return super.getFunctionNames(kindFilter, nameFilter) + listOf(DescriptorUtils.ENUM_VALUE_OF, DescriptorUtils.ENUM_VALUES) + return super.computeFunctionNames(kindFilter, nameFilter) + listOf(DescriptorUtils.ENUM_VALUE_OF, DescriptorUtils.ENUM_VALUES) } - return super.getFunctionNames(kindFilter, nameFilter) + return super.computeFunctionNames(kindFilter, nameFilter) } - override fun getPropertyNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection = + override fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection = memberIndex().getAllFieldNames() - override fun getClassNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection = listOf() + override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Collection = listOf() override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? { // We don't need to track lookups here because we find nested/inner classes in LazyJavaClassMemberScope