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

get rid of JetScopeSelectorUtil, inline its contents into Kotlin code

Browse Source
This commit is contained in:
Dmitry Jemerov
2015-06-01 19:22:43 +02:00
parent c57a0440ec
commit 758b94d3a6
3 changed files with 45 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
+18 -26
View File
@@ -29,9 +29,6 @@ import org.jetbrains.kotlin.resolve.PlatformTypesMappedToKotlinChecker
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.resolve.scopes.JetScopeSelectorUtil
import org.jetbrains.kotlin.resolve.scopes.JetScopeSelectorUtil.ScopeByNameMultiSelector
import org.jetbrains.kotlin.resolve.scopes.JetScopeSelectorUtil.ScopeByNameSelector
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.kotlin.utils.Printer
import java.util.HashSet
@@ -146,8 +143,7 @@ class LazyImportResolver(
val importedReference = importDirective.getImportedReference()
if (importedReference == null || resolvedTo == null) return
val aliasName = JetPsiUtil.getAliasName(importDirective)
if (aliasName == null) return
val aliasName = JetPsiUtil.getAliasName(importDirective) ?: return
if (resolvedTo.size() != 1) return
@@ -169,7 +165,7 @@ class LazyImportResolver(
public fun <D : DeclarationDescriptor> selectSingleFromImports(
name: Name,
lookupMode: LookupMode,
descriptorSelector: ScopeByNameSelector<D>
descriptorSelector: (JetScope, Name) -> D?
): D? {
fun compute(): D? {
val imports = indexedImports.importsForName(name)
@@ -180,7 +176,7 @@ class LazyImportResolver(
var target: D? = null
for (directive in imports) {
val resolved = descriptorSelector.get(getImportScope(directive, lookupMode), name) ?: continue
val resolved = descriptorSelector(getImportScope(directive, lookupMode), name) ?: continue
if (target != null && target != resolved) return null // ambiguity
target = resolved
}
@@ -192,7 +188,7 @@ class LazyImportResolver(
public fun <D : DeclarationDescriptor> collectFromImports(
name: Name,
lookupMode: LookupMode,
descriptorsSelector: ScopeByNameMultiSelector<D>
descriptorsSelector: (JetScope, Name) -> Collection<D>
): Collection<D> {
return resolveSession.getStorageManager().compute {
val descriptors = HashSet<D>()
@@ -202,7 +198,7 @@ class LazyImportResolver(
throw IllegalStateException("Recursion while resolving many imports: " + directive.getText())
}
descriptors.addAll(descriptorsSelector.get(getImportScope(directive, lookupMode), name))
descriptors.addAll(descriptorsSelector(getImportScope(directive, lookupMode), name))
}
descriptors
@@ -231,40 +227,36 @@ class LazyImportScope(
INVISIBLE_CLASSES
}
private val classifierDescriptorSelector = object : ScopeByNameSelector<ClassifierDescriptor> {
override fun get(scope: JetScope, name: Name): ClassifierDescriptor? {
val descriptor = JetScopeSelectorUtil.CLASSIFIER_DESCRIPTOR_SCOPE_SELECTOR.get(scope, name)
return if (descriptor != null && filter(descriptor as ClassDescriptor/*no type parameter can be imported*/)) descriptor else null
}
private fun filter(descriptor: ClassDescriptor): Boolean {
if (filteringKind == FilteringKind.ALL) return true
val visibility = descriptor.getVisibility()
val includeVisible = filteringKind == FilteringKind.VISIBLE_CLASSES
if (!visibility.mustCheckInImports()) return includeVisible
return Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, descriptor, importResolver.packageView) == includeVisible
}
fun isClassVisible(descriptor: ClassDescriptor): Boolean {
if (filteringKind == FilteringKind.ALL) return true
val visibility = descriptor.getVisibility()
val includeVisible = filteringKind == FilteringKind.VISIBLE_CLASSES
if (!visibility.mustCheckInImports()) return includeVisible
return Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, descriptor, importResolver.packageView) == includeVisible
}
override fun getClassifier(name: Name): ClassifierDescriptor? {
return importResolver.selectSingleFromImports(name, LookupMode.ONLY_CLASSES_AND_PACKAGES, classifierDescriptorSelector)
return importResolver.selectSingleFromImports(name, LookupMode.ONLY_CLASSES_AND_PACKAGES) { scope, name ->
val descriptor = scope.getClassifier(name)
if (descriptor != null && isClassVisible(descriptor as ClassDescriptor/*no type parameter can be imported*/)) descriptor else null
}
}
override fun getPackage(name: Name): PackageViewDescriptor? {
if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return null
return importResolver.selectSingleFromImports(name, LookupMode.ONLY_CLASSES_AND_PACKAGES, JetScopeSelectorUtil.PACKAGE_SCOPE_SELECTOR)
return importResolver.selectSingleFromImports(name, LookupMode.ONLY_CLASSES_AND_PACKAGES) { scope, name -> scope.getPackage(name) }
}
override fun getProperties(name: Name): Collection<VariableDescriptor> {
if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
return importResolver.collectFromImports(name, LookupMode.EVERYTHING, JetScopeSelectorUtil.NAMED_PROPERTIES_SCOPE_SELECTOR)
return importResolver.collectFromImports(name, LookupMode.EVERYTHING) { scope, name -> scope.getProperties(name) }
}
override fun getLocalVariable(name: Name) = null
override fun getFunctions(name: Name): Collection<FunctionDescriptor> {
if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
return importResolver.collectFromImports(name, LookupMode.EVERYTHING, JetScopeSelectorUtil.NAMED_FUNCTION_SCOPE_SELECTOR)
return importResolver.collectFromImports(name, LookupMode.EVERYTHING) { scope, name -> scope.getFunctions(name) }
}
override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = listOf()
core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt
+27 -6
View File
@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.utils.Printer
import java.util.*
import org.jetbrains.kotlin.resolve.scopes.JetScopeSelectorUtil.*
public open class ChainedScope(
private val containingDeclaration: DeclarationDescriptor?/* it's nullable as a hack for TypeUtils.intersect() */,
@@ -30,20 +29,42 @@ public open class ChainedScope(
private val scopeChain = scopes.clone()
private var implicitReceiverHierarchy: List<ReceiverParameterDescriptor>? = null
private inline fun getFirstMatch<T>(callback: (JetScope) -> T): T {
// NOTE: This is performance-sensitive; please don't replace with map().firstOrNull()
for (scope in scopeChain) {
val result = callback(scope)
if (result != null) return result
}
return null
}
private inline fun getFromAllScopes<T>(callback: (JetScope) -> Collection<T>): Set<T> {
if (scopeChain.isEmpty()) return emptySet()
var result: MutableSet<T>? = null
for (scope in scopeChain) {
val fromScope = callback(scope)
if (result == null) {
result = LinkedHashSet<T>()
}
result.addAll(fromScope)
}
return result ?: emptySet()
}
override fun getClassifier(name: Name): ClassifierDescriptor?
= getFirstMatch(scopeChain, name, CLASSIFIER_DESCRIPTOR_SCOPE_SELECTOR)
= getFirstMatch { it.getClassifier(name) }
override fun getPackage(name: Name): PackageViewDescriptor?
= getFirstMatch(scopeChain, name, PACKAGE_SCOPE_SELECTOR)
= getFirstMatch { it.getPackage(name) }
override fun getProperties(name: Name): Set<VariableDescriptor>
= getFromAllScopes(scopeChain, name, NAMED_PROPERTIES_SCOPE_SELECTOR)
= getFromAllScopes { it.getProperties(name) }
override fun getLocalVariable(name: Name): VariableDescriptor?
= getFirstMatch(scopeChain, name, VARIABLE_DESCRIPTOR_SCOPE_SELECTOR)
= getFirstMatch { it.getLocalVariable(name) }
override fun getFunctions(name: Name): Set<FunctionDescriptor>
= getFromAllScopes(scopeChain, name, NAMED_FUNCTION_SCOPE_SELECTOR)
= getFromAllScopes { it.getFunctions(name) }
override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> {
if (implicitReceiverHierarchy == null) {
core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeSelectorUtil.java
-128
View File
@@ -1,128 +0,0 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.name.Name;
import java.util.*;
public class JetScopeSelectorUtil {
private JetScopeSelectorUtil() {
}
public interface ScopeByNameSelector<D extends DeclarationDescriptor> {
@Nullable
D get(@NotNull JetScope scope, @NotNull Name name);
}
public interface ScopeByNameMultiSelector<D extends DeclarationDescriptor> {
@NotNull
Collection<D> get(JetScope scope, Name name);
}
@NotNull
public static <D extends DeclarationDescriptor> Collection<D> collect(Collection<JetScope> scopes, ScopeByNameMultiSelector<D> selector, Name name) {
Set<D> descriptors = new HashSet<D>();
for (JetScope scope : scopes) {
descriptors.addAll(selector.get(scope, name));
}
return descriptors;
}
public static final ScopeByNameSelector<ClassifierDescriptor> CLASSIFIER_DESCRIPTOR_SCOPE_SELECTOR =
new ScopeByNameSelector<ClassifierDescriptor>() {
@Nullable
@Override
public ClassifierDescriptor get(@NotNull JetScope scope, @NotNull Name name) {
return scope.getClassifier(name);
}
};
public static final ScopeByNameSelector<PackageViewDescriptor> PACKAGE_SCOPE_SELECTOR =
new ScopeByNameSelector<PackageViewDescriptor>() {
@Nullable
@Override
public PackageViewDescriptor get(@NotNull JetScope scope, @NotNull Name name) {
return scope.getPackage(name);
}
};
public static final ScopeByNameSelector<VariableDescriptor> VARIABLE_DESCRIPTOR_SCOPE_SELECTOR =
new ScopeByNameSelector<VariableDescriptor>() {
@Nullable
@Override
public VariableDescriptor get(@NotNull JetScope scope, @NotNull Name name) {
return scope.getLocalVariable(name);
}
};
public static final ScopeByNameMultiSelector<FunctionDescriptor> NAMED_FUNCTION_SCOPE_SELECTOR =
new ScopeByNameMultiSelector<FunctionDescriptor>() {
@NotNull
@Override
public Collection<FunctionDescriptor> get(@NotNull JetScope scope, @NotNull Name name) {
return scope.getFunctions(name);
}
};
public static final ScopeByNameMultiSelector<VariableDescriptor> NAMED_PROPERTIES_SCOPE_SELECTOR =
new ScopeByNameMultiSelector<VariableDescriptor>() {
@NotNull
@Override
public Collection<VariableDescriptor> get(@NotNull JetScope scope, @NotNull Name name) {
return scope.getProperties(name);
}
};
@Nullable
public static <D extends DeclarationDescriptor> D getFirstMatch(
@NotNull JetScope[] scopes,
@NotNull Name name,
@NotNull ScopeByNameSelector<D> descriptorSelector
) {
for (JetScope scope : scopes) {
D descriptor = descriptorSelector.get(scope, name);
if (descriptor != null) {
return descriptor;
}
}
return null;
}
@NotNull
public static <D extends DeclarationDescriptor> Set<D> getFromAllScopes(
@NotNull JetScope[] scopes,
@NotNull Name name,
@NotNull ScopeByNameMultiSelector<D> descriptorsSelector
) {
if (scopes.length == 0) return Collections.emptySet();
Set<D> descriptors = new LinkedHashSet<D>();
for (JetScope jetScope : scopes) {
descriptors.addAll(descriptorsSelector.get(jetScope, name));
}
return descriptors;
}
}