From 2e678a94f1653f0f6d390aa323661accb9a37c71 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 28 Mar 2013 18:17:21 +0400 Subject: [PATCH] Replaced predicate strategy with priority-returning strategy. --- .../calls/tasks/ResolutionTaskHolder.java | 26 ++++++++++++++----- .../resolve/calls/tasks/TaskPrioritizer.java | 13 ++++++---- 2 files changed, 28 insertions(+), 11 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java index cb884129ad2..fafd36bea63 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java @@ -17,11 +17,11 @@ package org.jetbrains.jet.lang.resolve.calls.tasks; import com.google.common.base.Predicate; -import com.google.common.base.Predicates; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.psi.JetReferenceExpression; @@ -31,9 +31,12 @@ import java.util.Collection; import java.util.List; public class ResolutionTaskHolder { + private static final int MIN_PRIORITY = 0; + private static final int MAX_PRIORITY = 1; + private final JetReferenceExpression reference; private final BasicCallResolutionContext basicCallResolutionContext; - private final Predicate> visibleStrategy; + private final PriorityProvider> priorityProvider; private final boolean isSafeCall; private final Collection>> localExtensions = Sets.newLinkedHashSet(); @@ -44,10 +47,11 @@ public class ResolutionTaskHolder { public ResolutionTaskHolder(@NotNull JetReferenceExpression reference, @NotNull BasicCallResolutionContext basicCallResolutionContext, - @NotNull Predicate> visibleStrategy) { + @NotNull PriorityProvider> priorityProvider + ) { this.reference = reference; this.basicCallResolutionContext = basicCallResolutionContext; - this.visibleStrategy = visibleStrategy; + this.priorityProvider = priorityProvider; this.isSafeCall = JetPsiUtil.isSafeCall(basicCallResolutionContext.call); } @@ -93,9 +97,15 @@ public class ResolutionTaskHolder { } candidateList.addAll(nonLocalExtensions); - for (Predicate> visibilityStrategy : Lists.newArrayList(visibleStrategy, Predicates.not(visibleStrategy))) { + for (int priority = MAX_PRIORITY; priority >= MIN_PRIORITY; priority--) { + final int finalPriority = priority; for (Collection> candidates : candidateList) { - Collection> filteredCandidates = Collections2.filter(candidates, visibilityStrategy); + Collection> filteredCandidates = Collections2.filter(candidates, new Predicate>() { + @Override + public boolean apply(@Nullable ResolutionCandidate input) { + return finalPriority == priorityProvider.getPriority(input); + } + }); if (!filteredCandidates.isEmpty()) { tasks.add(new ResolutionTask(filteredCandidates, reference, basicCallResolutionContext)); } @@ -104,4 +114,8 @@ public class ResolutionTaskHolder { } return tasks; } + + public interface PriorityProvider { + int getPriority(D candidate); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java index cfdb5b6d7c1..d812de0db67 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.lang.resolve.calls.tasks; -import com.google.common.base.Predicate; import com.google.common.collect.Lists; import com.intellij.openapi.progress.ProgressIndicatorProvider; import org.jetbrains.annotations.NotNull; @@ -26,8 +25,8 @@ import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.psi.JetSuperExpression; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext; import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl; +import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils; @@ -78,7 +77,7 @@ public class TaskPrioritizer { public static List> computePrioritizedTasks(@NotNull final BasicCallResolutionContext context, @NotNull Name name, @NotNull JetReferenceExpression functionReference, @NotNull List> callableDescriptorCollectors) { ReceiverValue explicitReceiver = context.call.getExplicitReceiver(); - final JetScope scope; + JetScope scope; if (explicitReceiver.exists() && explicitReceiver.getType() instanceof NamespaceType) { // Receiver is a namespace scope = explicitReceiver.getType().getMemberScope(); @@ -87,9 +86,13 @@ public class TaskPrioritizer { else { scope = context.scope; } - Predicate> visibleStrategy = new Predicate>() { + ResolutionTaskHolder.PriorityProvider> visibleStrategy = new ResolutionTaskHolder.PriorityProvider>() { @Override - public boolean apply(@Nullable ResolutionCandidate call) { + public int getPriority(ResolutionCandidate call) { + return isVisible(call) ? 1 : 0; + } + + private boolean isVisible(ResolutionCandidate call) { if (call == null) return false; D candidateDescriptor = call.getDescriptor(); if (ErrorUtils.isError(candidateDescriptor)) return true;