From 41e4b1ce9b6c8aecf9b949ebeaa4154dcdec99e2 Mon Sep 17 00:00:00 2001 From: Michael Bogdanov Date: Thu, 5 Mar 2015 15:25:43 +0300 Subject: [PATCH] Set proper call element --- .../resolve/DelegatedPropertyResolver.java | 2 +- .../expressions/ExpressionTypingUtils.java | 21 ++++++++++++------- .../ForLoopConventionsChecker.java | 5 +++-- .../resolve/JetExpectedResolveDataUtil.java | 2 +- 4 files changed, 18 insertions(+), 12 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java index 351172c1155..a01d13543e7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java @@ -252,7 +252,7 @@ public class DelegatedPropertyResolver { JetReferenceExpression fakeCalleeExpression = psiFactory.createSimpleName(functionName.asString()); ExpressionReceiver receiver = new ExpressionReceiver(delegateExpression, delegateType); - Call call = CallMaker.makeCallWithExpressions(fakeCalleeExpression, receiver, null, fakeCalleeExpression, arguments, Call.CallType.DEFAULT); + Call call = CallMaker.makeCallWithExpressions(delegateExpression, receiver, null, fakeCalleeExpression, arguments, Call.CallType.DEFAULT); trace.record(BindingContext.DELEGATED_PROPERTY_CALL, accessor, call); return callResolver.resolveCallWithGivenName(context, call, fakeCalleeExpression, functionName); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java index 210565998d4..aabdf737744 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java @@ -171,6 +171,7 @@ public class ExpressionTypingUtils { @NotNull ExpressionTypingContext context, @NotNull ReceiverValue receiver, @NotNull Name name, + @Nullable JetExpression callElement, @NotNull JetType... argumentTypes ) { TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", @@ -180,7 +181,8 @@ public class ExpressionTypingUtils { fakeArguments.add(createFakeExpressionOfType(expressionTypingServices.getProject(), traceWithFakeArgumentInfo, "fakeArgument" + fakeArguments.size(), type)); } - return makeAndResolveFakeCall(receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), fakeArguments, name).getSecond(); + return makeAndResolveFakeCall(receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), fakeArguments, name, + callElement).getSecond(); } public static JetExpression createFakeExpressionOfType( @@ -199,9 +201,10 @@ public class ExpressionTypingUtils { public OverloadResolutionResults resolveFakeCall( @NotNull ExpressionTypingContext context, @NotNull ReceiverValue receiver, - @NotNull Name name + @NotNull Name name, + @NotNull JetExpression callElement ) { - return resolveFakeCall(receiver, context, Collections.emptyList(), name); + return resolveFakeCall(receiver, context, Collections.emptyList(), name, callElement); } @NotNull @@ -209,9 +212,10 @@ public class ExpressionTypingUtils { @NotNull ReceiverValue receiver, @NotNull ExpressionTypingContext context, @NotNull List valueArguments, - @NotNull Name name + @NotNull Name name, + @NotNull JetExpression callElement ) { - return makeAndResolveFakeCall(receiver, context, valueArguments, name).getSecond(); + return makeAndResolveFakeCall(receiver, context, valueArguments, name, callElement).getSecond(); } @NotNull @@ -219,11 +223,12 @@ public class ExpressionTypingUtils { @NotNull ReceiverValue receiver, @NotNull ExpressionTypingContext context, @NotNull List valueArguments, - @NotNull Name name + @NotNull Name name, + @Nullable JetExpression callElement ) { final JetReferenceExpression fake = JetPsiFactory(expressionTypingServices.getProject()).createSimpleName("fake"); TemporaryBindingTrace fakeTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve fake call for", name); - Call call = CallMaker.makeCallWithExpressions(fake, receiver, null, fake, valueArguments); + Call call = CallMaker.makeCallWithExpressions(callElement != null ? callElement : fake, receiver, null, fake, valueArguments); OverloadResolutionResults results = callResolver.resolveCallWithGivenName(context.replaceBindingTrace(fakeTrace), call, fake, name); if (results.isSuccess()) { @@ -252,7 +257,7 @@ public class ExpressionTypingUtils { JetType expectedType = getExpectedTypeForComponent(context, entry); OverloadResolutionResults results = - resolveFakeCall(context.replaceExpectedType(expectedType), receiver, componentName); + resolveFakeCall(context.replaceExpectedType(expectedType), receiver, componentName, entry); JetType componentType = null; if (results.isSuccess()) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java index fa8af280abb..ea248ec0f62 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java @@ -73,7 +73,8 @@ public class ForLoopConventionsChecker { // Make a fake call loopRange.iterator(), and try to resolve it Name iterator = Name.identifier("iterator"); Pair> calls = - expressionTypingUtils.makeAndResolveFakeCall(loopRange, context, Collections.emptyList(), iterator); + expressionTypingUtils.makeAndResolveFakeCall(loopRange, context, Collections.emptyList(), iterator, + loopRange.getExpression()); OverloadResolutionResults iteratorResolutionResults = calls.getSecond(); if (iteratorResolutionResults.isSuccess()) { @@ -115,7 +116,7 @@ public class ForLoopConventionsChecker { @NotNull WritableSlice> resolvedCallKey ) { OverloadResolutionResults nextResolutionResults = expressionTypingUtils.resolveFakeCall( - context, new TransientReceiver(iteratorType), Name.identifier(name)); + context, new TransientReceiver(iteratorType), Name.identifier(name), loopRangeExpression); if (nextResolutionResults.isAmbiguity()) { context.trace.report(ambiguity.on(loopRangeExpression, iteratorType)); } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java index 1858e23e3c8..a5788be9120 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java @@ -135,7 +135,7 @@ public class JetExpectedResolveDataUtil { DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE); OverloadResolutionResults functions = injector.getExpressionTypingUtils().resolveFakeCall( - context, ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypes); + context, ReceiverValue.NO_RECEIVER, Name.identifier(name), null, parameterTypes); for (ResolvedCall resolvedCall : functions.getResultingCalls()) { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters();