From 703e4d7c4e0de913cf017dd7454af3fdf901a3ac Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 23 Apr 2014 16:22:37 +0400 Subject: [PATCH] Refactoring: separated VariableAsFunctionResolvedCall interface and implementation --- .../lang/resolve/calls/CallTransformer.java | 4 +- .../calls/model/MutableResolvedCall.java | 1 + .../model/VariableAsFunctionResolvedCall.java | 165 ------------------ .../model/VariableAsFunctionResolvedCall.kt | 55 ++++++ .../results/OverloadingConflictResolver.java | 3 +- .../calls/results/ResolutionStatus.java | 3 + .../calls/AbstractResolvedCallsTest.kt | 4 +- .../JetInvokeFunctionReference.java | 4 +- .../callTranslator/CallTranslator.kt | 8 +- 9 files changed, 71 insertions(+), 176 deletions(-) delete mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java index 05212a568c6..d499ec362cd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.resolve.calls.context.CallCandidateResolutionConte import org.jetbrains.jet.lang.resolve.calls.context.ContextDependency; import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl; -import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCallImpl; import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl; import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind; @@ -215,7 +215,7 @@ public class CallTransformer { return Collections2.transform(calls, new Function, MutableResolvedCall>() { @Override public MutableResolvedCall apply(MutableResolvedCall functionResolvedCall) { - return new VariableAsFunctionResolvedCall(functionResolvedCall, variableResolvedCall); + return new VariableAsFunctionResolvedCallImpl(functionResolvedCall, variableResolvedCall); } }); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java index 967c0ef9233..1f1e5281689 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/MutableResolvedCall.java @@ -36,6 +36,7 @@ public interface MutableResolvedCall extends Resol boolean isDirty(); + @NotNull DelegatingBindingTrace getTrace(); /** diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.java deleted file mode 100644 index e46b414f2db..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.java +++ /dev/null @@ -1,165 +0,0 @@ -/* - * Copyright 2010-2013 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.model; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; -import org.jetbrains.jet.lang.psi.Call; -import org.jetbrains.jet.lang.psi.ValueArgument; -import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace; -import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind; -import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus; -import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.jet.lang.types.JetType; - -import java.util.List; -import java.util.Map; - -public class VariableAsFunctionResolvedCall implements MutableResolvedCall { - private final MutableResolvedCall functionCall; - private final MutableResolvedCall variableCall; - - public VariableAsFunctionResolvedCall(@NotNull MutableResolvedCall functionCall, - @NotNull MutableResolvedCall variableCall) { - this.functionCall = functionCall; - this.variableCall = variableCall; - } - - @NotNull - public MutableResolvedCall getFunctionCall() { - return functionCall; - } - - @NotNull - public MutableResolvedCall getVariableCall() { - return variableCall; - } - - @NotNull - @Override - public Call getCall() { - return variableCall.getCall(); - } - - @NotNull - @Override - public FunctionDescriptor getCandidateDescriptor() { - return functionCall.getResultingDescriptor(); - } - - @NotNull - @Override - public FunctionDescriptor getResultingDescriptor() { - return functionCall.getResultingDescriptor(); - } - - @NotNull - @Override - public ReceiverValue getReceiverArgument() { - return variableCall.getReceiverArgument(); - } - - @NotNull - @Override - public ReceiverValue getThisObject() { - return variableCall.getThisObject(); - } - - @NotNull - @Override - public ExplicitReceiverKind getExplicitReceiverKind() { - return variableCall.getExplicitReceiverKind(); - } - - @NotNull - @Override - public Map getValueArguments() { - return functionCall.getValueArguments(); - } - - @Nullable - @Override - public List getValueArgumentsByIndex() { - return functionCall.getValueArgumentsByIndex(); - } - - @NotNull - @Override - public ArgumentMapping getArgumentMapping(@NotNull ValueArgument valueArgument) { - return functionCall.getArgumentMapping(valueArgument); - } - - @NotNull - @Override - public Map getTypeArguments() { - return functionCall.getTypeArguments(); - } - - @NotNull - @Override - public ResolutionStatus getStatus() { - return variableCall.getStatus().combine(functionCall.getStatus()); - } - - @Override - public boolean isDirty() { - return functionCall.isDirty(); - } - - @Override - public DelegatingBindingTrace getTrace() { - //functionCall.trace is temporary trace above variableCall.trace and is committed already - return variableCall.getTrace(); - } - - @Override - public boolean isSafeCall() { - return variableCall.isSafeCall() || functionCall.isSafeCall(); - } - - @Override - public boolean hasIncompleteTypeParameters() { - return variableCall.hasIncompleteTypeParameters(); - } - - @NotNull - @Override - public ResolvedCallImpl getCallToCompleteTypeArgumentInference() { - return functionCall.getCallToCompleteTypeArgumentInference(); - } - - @NotNull - @Override - public DataFlowInfoForArguments getDataFlowInfoForArguments() { - return functionCall.getDataFlowInfoForArguments(); - } - - @Override - public void markCallAsCompleted() { - functionCall.markCallAsCompleted(); - variableCall.markCallAsCompleted(); - } - - @Override - public boolean isCompleted() { - return functionCall.isCompleted() && variableCall.isCompleted(); - } -} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.kt new file mode 100644 index 00000000000..a8e30db4788 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/VariableAsFunctionResolvedCall.kt @@ -0,0 +1,55 @@ +/* + * Copyright 2010-2014 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.model + +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor +import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor +import org.jetbrains.jet.lang.descriptors.VariableDescriptor +import org.jetbrains.jet.lang.psi.Call +import org.jetbrains.jet.lang.psi.ValueArgument +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor +import org.jetbrains.jet.lang.types.JetType +import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus +import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace + +public trait VariableAsFunctionResolvedCall { + public val functionCall: ResolvedCall + public val variableCall: ResolvedCall +} + +class VariableAsFunctionResolvedCallImpl( + public override val functionCall: MutableResolvedCall, + public override val variableCall: MutableResolvedCall +) : VariableAsFunctionResolvedCall, MutableResolvedCall by functionCall { + + override fun markCallAsCompleted() { + functionCall.markCallAsCompleted() + variableCall.markCallAsCompleted() + } + + override fun isCompleted(): Boolean = functionCall.isCompleted() && variableCall.isCompleted() + + override fun getStatus(): ResolutionStatus = variableCall.getStatus().combine(functionCall.getStatus()) + + override fun getTrace(): DelegatingBindingTrace { + //functionCall.trace is temporary trace above variableCall.trace and is committed already + return variableCall.getTrace() + } + +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java index d2f7f1b4253..03901b7d70a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java @@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; @@ -89,7 +90,7 @@ public class OverloadingConflictResolver { if (!isInvoke) return false; assert otherCall instanceof VariableAsFunctionResolvedCall : "'invoke' candidate goes with usual one: " + candidateCall + otherCall; - MutableResolvedCall otherVariableCall = ((VariableAsFunctionResolvedCall) otherCall).getVariableCall(); + ResolvedCall otherVariableCall = ((VariableAsFunctionResolvedCall) otherCall).getVariableCall(); if (definitelyNotMaximallySpecific(variable, otherVariableCall.getResultingDescriptor(), discriminateGenericDescriptors)) { return false; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionStatus.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionStatus.java index 22df4c52148..36857ef6540 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionStatus.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionStatus.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.lang.resolve.calls.results; +import org.jetbrains.annotations.NotNull; + import java.util.EnumSet; public enum ResolutionStatus { @@ -55,6 +57,7 @@ public enum ResolutionStatus { return success; } + @NotNull public ResolutionStatus combine(ResolutionStatus other) { if (this == UNKNOWN_STATUS) return other; if (SUCCESS.among(this, other)) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt b/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt index 9d08d945929..5381a37233d 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt +++ b/compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt @@ -80,8 +80,8 @@ public abstract class AbstractResolvedCallsTest() : JetLiteFixture() { } if (resolvedCall is VariableAsFunctionResolvedCall) { - tryCall(resolvedCall.getFunctionCall(), "invoke") - tryCall(resolvedCall.getVariableCall()) + tryCall(resolvedCall.functionCall, "invoke") + tryCall(resolvedCall.variableCall) } else { tryCall(resolvedCall) diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java index c95b5a05ee6..67ed53ec86d 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java +++ b/idea/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java @@ -23,7 +23,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall; import org.jetbrains.jet.lexer.JetTokens; @@ -53,7 +52,8 @@ class JetInvokeFunctionReference extends JetSimpleReference i JetExpression calleeExpression = getExpression().getCalleeExpression(); ResolvedCall resolvedCall = context.get(RESOLVED_CALL, calleeExpression); if (resolvedCall instanceof VariableAsFunctionResolvedCall) { - return Collections.singleton(((VariableAsFunctionResolvedCall) resolvedCall).getCandidateDescriptor()); + return Collections.singleton( + ((VariableAsFunctionResolvedCall) resolvedCall).getFunctionCall().getCandidateDescriptor()); } Call call = context.get(CALL, calleeExpression); if (call != null && resolvedCall != null && call.getCallType() == Call.CallType.INVOKE) { diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/callTranslator/CallTranslator.kt b/js/js.translator/src/org/jetbrains/k2js/translate/callTranslator/CallTranslator.kt index 140eab1370f..4b0f755191d 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/callTranslator/CallTranslator.kt +++ b/js/js.translator/src/org/jetbrains/k2js/translate/callTranslator/CallTranslator.kt @@ -85,16 +85,16 @@ private fun translateCall(context: TranslationContext, ): JsExpression { if (resolvedCall is VariableAsFunctionResolvedCall) { assert(explicitReceivers.receiverObject == null, "VariableAsFunctionResolvedCall must have one receiver") - val variableCall = resolvedCall.getVariableCall() + val variableCall = resolvedCall.variableCall if (variableCall.expectedReceivers()) { val newReceiver = CallTranslator.translateGet(context, variableCall, explicitReceivers.receiverOrThisObject) - return translateFunctionCall(context, resolvedCall.getFunctionCall(), ExplicitReceivers(newReceiver)) + return translateFunctionCall(context, resolvedCall.functionCall, ExplicitReceivers(newReceiver)) } else { val thisObject = CallTranslator.translateGet(context, variableCall, null) if (explicitReceivers.receiverOrThisObject == null) - return translateFunctionCall(context, resolvedCall.getFunctionCall(), ExplicitReceivers(thisObject)) + return translateFunctionCall(context, resolvedCall.functionCall, ExplicitReceivers(thisObject)) else - return translateFunctionCall(context, resolvedCall.getFunctionCall(), ExplicitReceivers(thisObject, explicitReceivers.receiverOrThisObject)) + return translateFunctionCall(context, resolvedCall.functionCall, ExplicitReceivers(thisObject, explicitReceivers.receiverOrThisObject)) } }