From 2fa8fd50fcc5d88601d225fcce27bbacab464228 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Mon, 30 Apr 2012 15:26:28 +0400 Subject: [PATCH] 'getNonMembersByName' instead of 'getExtensionsByName' not to throw out invocation of variables with members-extensions --- .../calls/CallableDescriptorCollector.java | 38 ++++++++++ ...java => CallableDescriptorCollectors.java} | 70 ++++++------------- .../lang/resolve/calls/TaskPrioritizer.java | 37 +++++----- 3 files changed, 82 insertions(+), 63 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java rename compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/{MemberPrioritizers.java => CallableDescriptorCollectors.java} (60%) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java new file mode 100644 index 00000000000..27d9c77c400 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2012 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.jet.lang.resolve.calls; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; + +/** + * @author svtk + */ +public interface CallableDescriptorCollector { + @NotNull + Collection getNonExtensionsByName(JetScope scope, String name); + + @NotNull + Collection getMembersByName(@NotNull JetType receiver, String name); + + @NotNull + Collection getNonMembersByName(JetScope scope, String name); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizers.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollectors.java similarity index 60% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizers.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollectors.java index a7e793dcb4a..9e018ec229c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizers.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollectors.java @@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.ErrorUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.JetType; import java.util.*; @@ -34,11 +33,9 @@ import java.util.*; /** * @author abreslav */ -public class MemberPrioritizers { - - - /*package*/ static MemberPrioritizer FUNCTION_TASK_PRIORITIZER = new MemberPrioritizer() { +public class CallableDescriptorCollectors { + /*package*/ static CallableDescriptorCollector FUNCTIONS = new CallableDescriptorCollector() { @NotNull @Override @@ -51,8 +48,6 @@ public class MemberPrioritizers { } } addConstructors(scope, name, functions); - - addVariableAsFunction(scope, name, functions, false); return functions; } @@ -62,22 +57,13 @@ public class MemberPrioritizers { JetScope receiverScope = receiverType.getMemberScope(); Set members = Sets.newHashSet(receiverScope.getFunctions(name)); addConstructors(receiverScope, name, members); - addVariableAsFunction(receiverScope, name, members, false); return members; } @NotNull @Override - public Collection getExtensionsByName(JetScope scope, String name) { - Set extensionFunctions = Sets.newHashSet(scope.getFunctions(name)); - for (Iterator iterator = extensionFunctions.iterator(); iterator.hasNext(); ) { - FunctionDescriptor descriptor = iterator.next(); - if (!descriptor.getReceiverParameter().exists()) { - iterator.remove(); - } - } - addVariableAsFunction(scope, name, extensionFunctions, true); - return extensionFunctions; + public Collection getNonMembersByName(JetScope scope, String name) { + return scope.getFunctions(name); } private void addConstructors(JetScope scope, String name, Collection functions) { @@ -87,25 +73,9 @@ public class MemberPrioritizers { functions.addAll(classDescriptor.getConstructors()); } } - - private void addVariableAsFunction(JetScope scope, String name, Set functions, boolean receiverNeeded) { - VariableDescriptor variable = scope.getLocalVariable(name); - if (variable == null) { - variable = DescriptorUtils.filterNonExtensionProperty(scope.getProperties(name)); - } - if (variable != null) { - JetType outType = variable.getType(); - if (outType != null && JetStandardClasses.isFunctionType(outType)) { - VariableAsFunctionDescriptor functionDescriptor = VariableAsFunctionDescriptor.create(variable); - if ((functionDescriptor.getReceiverParameter().exists()) == receiverNeeded) { - functions.add(functionDescriptor); - } - } - } - } }; - /*package*/ static MemberPrioritizer VARIABLE_TASK_PRIORITIZER = new MemberPrioritizer() { + /*package*/ static CallableDescriptorCollector VARIABLES = new CallableDescriptorCollector() { @NotNull @Override @@ -126,17 +96,19 @@ public class MemberPrioritizers { @NotNull @Override - public Collection getExtensionsByName(JetScope scope, String name) { - return Collections2.filter(scope.getProperties(name), new Predicate() { - @Override - public boolean apply(@Nullable VariableDescriptor variableDescriptor) { - return (variableDescriptor != null) && variableDescriptor.getReceiverParameter().exists(); - } - }); + public Collection getNonMembersByName(JetScope scope, String name) { + Collection result = Sets.newLinkedHashSet(); + + VariableDescriptor localVariable = scope.getLocalVariable(name); + if (localVariable != null) { + result.add(localVariable); + } + result.addAll(scope.getProperties(name)); + return result; } }; - /*package*/ static MemberPrioritizer PROPERTY_TASK_PRIORITIZER = new MemberPrioritizer() { + /*package*/ static CallableDescriptorCollector PROPERTIES = new CallableDescriptorCollector() { private Collection filterProperties(Collection variableDescriptors) { ArrayList properties = Lists.newArrayList(); for (VariableDescriptor descriptor : variableDescriptors) { @@ -150,19 +122,23 @@ public class MemberPrioritizers { @NotNull @Override public Collection getNonExtensionsByName(JetScope scope, String name) { - return filterProperties(VARIABLE_TASK_PRIORITIZER.getNonExtensionsByName(scope, name)); + return filterProperties(VARIABLES.getNonExtensionsByName(scope, name)); } @NotNull @Override public Collection getMembersByName(@NotNull JetType receiver, String name) { - return filterProperties(VARIABLE_TASK_PRIORITIZER.getMembersByName(receiver, name)); + return filterProperties(VARIABLES.getMembersByName(receiver, name)); } @NotNull @Override - public Collection getExtensionsByName(JetScope scope, String name) { - return filterProperties(VARIABLE_TASK_PRIORITIZER.getExtensionsByName(scope, name)); + public Collection getNonMembersByName(JetScope scope, String name) { + return filterProperties(VARIABLES.getNonMembersByName(scope, name)); } + }; + + /*package*/ static List> FUNCTIONS_AND_VARIABLES = Lists.newArrayList( + FUNCTIONS, VARIABLES); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java index 6a1cd61c00f..eb3f565adab 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java @@ -74,8 +74,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor } @NotNull - public static List> computePrioritizedTasks(@NotNull BasicResolutionContext context, @NotNull String name, - @NotNull JetReferenceExpression functionReference, @NotNull List> memberPrioritizers) { + public static List> computePrioritizedTasks(@NotNull BasicResolutionContext context, @NotNull String name, + @NotNull JetReferenceExpression functionReference, @NotNull List> callableDescriptorCollectors) { ReceiverDescriptor explicitReceiver = context.call.getExplicitReceiver(); final JetScope scope; if (explicitReceiver.exists() && explicitReceiver.getType() instanceof NamespaceType) { @@ -96,23 +96,26 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor } }; - ResolutionTaskHolder result = new ResolutionTaskHolder(functionReference, context, visibleStrategy ); - doComputeTasks(scope, explicitReceiver, name, result, context, memberPrioritizers); - + ResolutionTaskHolder result = new ResolutionTaskHolder(functionReference, context, visibleStrategy ); + for (CallableDescriptorCollector callableDescriptorCollector : callableDescriptorCollectors) { + doComputeTasks(scope, explicitReceiver, name, result, context, callableDescriptorCollector); + } return result.getTasks(); } - private static void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, - @NotNull String name, @NotNull ResolutionTaskHolder result, - @NotNull BasicResolutionContext context, @NotNull List> memberPrioritizers) { - MemberPrioritizer memberPrioritizer = memberPrioritizers.get(0); + private static void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, + @NotNull String name, @NotNull ResolutionTaskHolder result, + @NotNull BasicResolutionContext context, @NotNull CallableDescriptorCollector callableDescriptorCollector) { AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext()); List implicitReceivers = Lists.newArrayList(); scope.getImplicitReceiversHierarchy(implicitReceivers); + if (context.call.getThisObject().exists()) { + implicitReceivers.add(context.call.getThisObject()); + } if (receiver.exists()) { List variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver); - Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, memberPrioritizer.getExtensionsByName(scope, name)); + Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(scope, name)); List> nonlocals = Lists.newArrayList(); List> locals = Lists.newArrayList(); //noinspection unchecked,RedundantTypeArguments @@ -120,7 +123,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor Collection> members = Lists.newArrayList(); for (ReceiverDescriptor variant : variantsForExplicitReceiver) { - Collection membersForThisVariant = memberPrioritizer.getMembersByName(variant.getType(), name); + Collection membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), name); convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members); } @@ -128,7 +131,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor result.addMembers(members); for (ReceiverDescriptor implicitReceiver : implicitReceivers) { - Collection memberExtensions = memberPrioritizer.getExtensionsByName(implicitReceiver.getType().getMemberScope(), name); + Collection memberExtensions = callableDescriptorCollector.getNonMembersByName( + implicitReceiver.getType().getMemberScope(), name); List variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver); result.addNonLocalExtensions(convertWithReceivers(memberExtensions, variantsForImplicitReceiver, variantsForExplicitReceiver)); } @@ -136,7 +140,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor result.addNonLocalExtensions(nonlocals); } else { - Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), memberPrioritizer.getNonExtensionsByName(scope, name)); + Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), callableDescriptorCollector + .getNonExtensionsByName(scope, name)); List> nonlocals = Lists.newArrayList(); List> locals = Lists.newArrayList(); @@ -147,18 +152,18 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor result.addNonLocalExtensions(nonlocals); for (ReceiverDescriptor implicitReceiver : implicitReceivers) { - doComputeTasks(scope, implicitReceiver, name, result, context, memberPrioritizers); + doComputeTasks(scope, implicitReceiver, name, result, context, callableDescriptorCollector); } } } - private static Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { + private static Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { Collection> result = Lists.newArrayList(); convertWithReceivers(descriptors, thisObjects, receiverParameters, result); return result; } - private static void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { + private static void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { for (ReceiverDescriptor thisObject : thisObjects) { for (ReceiverDescriptor receiverParameter : receiverParameters) { for (D extension : descriptors) {