From fbd94a95078708226a77cc3be4fed25b5878f84a Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Fri, 9 Aug 2013 18:33:11 +0400 Subject: [PATCH] rename ResolveMode to ContextDependency --- .../jet/lang/resolve/BodyResolver.java | 4 +-- .../resolve/calls/ArgumentTypeResolver.java | 7 +++-- .../resolve/calls/CallExpressionResolver.java | 7 +++-- .../jet/lang/resolve/calls/CallResolver.java | 6 ++--- .../lang/resolve/calls/CallTransformer.java | 2 +- .../lang/resolve/calls/CandidateResolver.java | 2 +- .../context/BasicCallResolutionContext.java | 18 ++++++------- .../CallCandidateResolutionContext.java | 16 ++++++------ .../calls/context/CallResolutionContext.java | 4 +-- ...esolveMode.java => ContextDependency.java} | 6 ++--- .../calls/context/ResolutionContext.java | 26 +++++++++---------- .../context/SimpleResolutionContext.java | 8 +++--- .../OverloadResolutionResultsUtil.java | 10 +++---- .../resolve/calls/tasks/ResolutionTask.java | 12 ++++----- .../BasicExpressionTypingVisitor.java | 8 +++--- .../expressions/ExpressionTypingContext.java | 16 ++++++------ .../expressions/ExpressionTypingServices.java | 2 +- .../ExpressionTypingVisitorForStatements.java | 4 +-- 18 files changed, 78 insertions(+), 80 deletions(-) rename compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/{ResolveMode.java => ContextDependency.java} (91%) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index b6e15ad2115..95d54fd9810 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -27,7 +27,7 @@ import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorUtil; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode; +import org.jetbrains.jet.lang.resolve.calls.context.ContextDependency; import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition; import org.jetbrains.jet.lang.resolve.calls.context.ResolutionResultsCacheImpl; import org.jetbrains.jet.lang.resolve.calls.context.SimpleResolutionContext; @@ -216,7 +216,7 @@ public class BodyResolver { JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, context.getOuterDataFlowInfo(), trace); if (type != null && supertype != null) { SimpleResolutionContext simpleResolutionContext = new SimpleResolutionContext( - trace, scope, supertype, context.getOuterDataFlowInfo(), ExpressionPosition.FREE, ResolveMode.NORMAL, + trace, scope, supertype, context.getOuterDataFlowInfo(), ExpressionPosition.FREE, ContextDependency.INDEPENDENT, ResolutionResultsCacheImpl.create()); DataFlowUtils.checkType(type, delegateExpression, simpleResolutionContext); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java index a2d60b9c165..1aa9a9de86e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java @@ -28,11 +28,9 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext; import org.jetbrains.jet.lang.resolve.calls.context.CheckValueArgumentsMode; import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext; -import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode; -import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintsUtil; +import org.jetbrains.jet.lang.resolve.calls.context.ContextDependency; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument; -import org.jetbrains.jet.lang.resolve.constants.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; @@ -175,7 +173,8 @@ public class ArgumentTypeResolver { if (recordedTypeInfo != null) { return recordedTypeInfo; } - ResolutionContext newContext = context.replaceExpectedType(TypeUtils.UNKNOWN_EXPECTED_TYPE).replaceResolveMode(ResolveMode.NESTED_CALL); + ResolutionContext newContext = context.replaceExpectedType(TypeUtils.UNKNOWN_EXPECTED_TYPE).replaceContextDependency( + ContextDependency.DEPENDENT); JetTypeInfo result = expressionTypingServices.getTypeInfo(expression, newContext); if (traceToCommitForCall != null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java index 1cd0fd0871f..89654ce164e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java @@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; -import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.context.*; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace; @@ -194,7 +193,7 @@ public class CallExpressionResolver { if (!results.isNothing()) { checkSuper(call.getExplicitReceiver(), results, context.trace, callExpression); result[0] = true; - return OverloadResolutionResultsUtil.getResultingCall(results, context.resolveMode); + return OverloadResolutionResultsUtil.getResultingCall(results, context.contextDependency); } result[0] = false; return null; @@ -284,7 +283,7 @@ public class CallExpressionResolver { ) { JetTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck( callExpression, receiver, callOperationNode, context); - if (context.resolveMode == ResolveMode.TOP_LEVEL_CALL) { + if (context.contextDependency == ContextDependency.INDEPENDENT) { DataFlowUtils.checkType(typeInfo.getType(), callExpression, context, typeInfo.getDataFlowInfo()); } return typeInfo; @@ -407,7 +406,7 @@ public class CallExpressionResolver { context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, selectorReturnType); } JetTypeInfo typeInfo = JetTypeInfo.create(selectorReturnType, selectorReturnTypeInfo.getDataFlowInfo()); - if (context.resolveMode == ResolveMode.TOP_LEVEL_CALL) { + if (context.contextDependency == ContextDependency.INDEPENDENT) { DataFlowUtils.checkType(typeInfo.getType(), expression, context, typeInfo.getDataFlowInfo()); } return typeInfo; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 7669d6ade2b..9a605b3ece4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -142,7 +142,7 @@ public class CallResolver { @NotNull DataFlowInfo dataFlowInfo ) { return resolveFunctionCall(BasicCallResolutionContext.create( - trace, scope, call, expectedType, dataFlowInfo, ResolveMode.TOP_LEVEL_CALL, CheckValueArgumentsMode.ENABLED, + trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED, ExpressionPosition.FREE, ResolutionResultsCacheImpl.create())); } @@ -319,7 +319,7 @@ public class CallResolver { } traceToResolveCall.commit(); - if (prioritizedTasks.isEmpty() || context.resolveMode == ResolveMode.NESTED_CALL) { + if (prioritizedTasks.isEmpty() || context.contextDependency == ContextDependency.DEPENDENT) { //do nothing } else { results = completeTypeInferenceDependentOnExpectedType(context, results, tracing); @@ -509,7 +509,7 @@ public class CallResolver { ImmutableSet someFailed = ImmutableSet.of(MANY_FAILED_CANDIDATES, SINGLE_CANDIDATE_ARGUMENT_MISMATCH); if (someFailed.contains(results.getResultCode()) && !task.call.getFunctionLiteralArguments().isEmpty() - && task.resolveMode == ResolveMode.TOP_LEVEL_CALL) { //For nested calls there are no such cases + && task.contextDependency == ContextDependency.INDEPENDENT) { //For nested calls there are no such cases // We have some candidates that failed for some reason // And we have a suspect: the function literal argument // Now, we try to remove this argument and see if it helps 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 8349fb53442..ebf320e3fd9 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 @@ -196,7 +196,7 @@ public class CallTransformer { DelegatingBindingTrace variableCallTrace = context.candidateCall.getTrace(); BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create( variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo, - context.resolveMode, context.checkArguments, context.expressionPosition, context.resolutionResultsCache); + context.contextDependency, context.checkArguments, context.expressionPosition, context.resolutionResultsCache); // 'invoke' call resolve OverloadResolutionResults results = callResolver.resolveCallWithGivenName(basicCallResolutionContext, task.reference, Name.identifier("invoke")); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java index ca5d3d1e58a..0ad8f62c61b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java @@ -363,7 +363,7 @@ public class CandidateResolver { } CallCandidateResolutionContext contextForArgument = storedContextForArgument - .replaceResolveMode(ResolveMode.TOP_LEVEL_CALL).replaceBindingTrace(context.trace).replaceExpectedType(expectedType); + .replaceContextDependency(ContextDependency.INDEPENDENT).replaceBindingTrace(context.trace).replaceExpectedType(expectedType); JetType type; if (contextForArgument.candidateCall.hasIncompleteTypeParameters()) { type = completeTypeInferenceDependentOnExpectedTypeForCall(contextForArgument, true); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java index b1647b05f83..51768095077 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java @@ -33,13 +33,13 @@ public class BasicCallResolutionContext extends CallResolutionContext @NotNull Call call, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, - @NotNull ResolveMode resolveMode, + @NotNull ContextDependency contextDependency, @NotNull CheckValueArgumentsMode checkArguments, @NotNull ExpressionPosition expressionPosition, @NotNull ResolutionResultsCache resolutionResultsCache ) { - super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache, null); + super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, expressionPosition, resolutionResultsCache, null); this.candidateCall = candidateCall; this.tracing = tracing; } @@ -56,7 +56,7 @@ public final class CallCandidateResolutionContext candidateCall.setInitialDataFlowInfo(context.dataFlowInfo); return new CallCandidateResolutionContext( candidateCall, tracing, trace, context.scope, call, context.expectedType, - context.dataFlowInfo, context.resolveMode, context.checkArguments, + context.dataFlowInfo, context.contextDependency, context.checkArguments, context.expressionPosition, context.resolutionResultsCache); } @@ -69,18 +69,18 @@ public final class CallCandidateResolutionContext public static CallCandidateResolutionContext createForCallBeingAnalyzed( @NotNull ResolvedCallImpl candidateCall, @NotNull BasicCallResolutionContext context, @NotNull TracingStrategy tracing ) { - return createForCallBeingAnalyzed(candidateCall, context, context.call, context.resolveMode, + return createForCallBeingAnalyzed(candidateCall, context, context.call, context.contextDependency, context.checkArguments, tracing, context.resolutionResultsCache); } public static CallCandidateResolutionContext createForCallBeingAnalyzed( @NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionContext context, @NotNull Call call, - @NotNull ResolveMode resolveMode, @NotNull CheckValueArgumentsMode checkArguments, @NotNull TracingStrategy tracing, + @NotNull ContextDependency contextDependency, @NotNull CheckValueArgumentsMode checkArguments, @NotNull TracingStrategy tracing, @NotNull ResolutionResultsCache resolutionResultsCache ) { return new CallCandidateResolutionContext( candidateCall, tracing, context.trace, context.scope, call, context.expectedType, - context.dataFlowInfo, resolveMode, checkArguments, context.expressionPosition, resolutionResultsCache); + context.dataFlowInfo, contextDependency, checkArguments, context.expressionPosition, resolutionResultsCache); } @Override @@ -90,11 +90,11 @@ public final class CallCandidateResolutionContext @NotNull DataFlowInfo dataFlowInfo, @NotNull JetType expectedType, @NotNull ExpressionPosition expressionPosition, - @NotNull ResolveMode resolveMode, + @NotNull ContextDependency contextDependency, @NotNull ResolutionResultsCache resolutionResultsCache ) { return new CallCandidateResolutionContext( - candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, + candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, expressionPosition, resolutionResultsCache); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java index a3105a6a09d..20af09e0429 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java @@ -37,13 +37,13 @@ public abstract class CallResolutionContext JetType getResultingType( @NotNull OverloadResolutionResults results, - @NotNull ResolveMode resolveMode + @NotNull ContextDependency contextDependency ) { - ResolvedCall resultingCall = getResultingCall((OverloadResolutionResultsImpl) results, resolveMode); + ResolvedCall resultingCall = getResultingCall((OverloadResolutionResultsImpl) results, contextDependency); return resultingCall != null ? resultingCall.getResultingDescriptor().getReturnType() : null; } @Nullable public static ResolvedCallWithTrace getResultingCall( @NotNull OverloadResolutionResultsImpl results, - @NotNull ResolveMode resolveMode + @NotNull ContextDependency contextDependency ) { - if (results.isSingleResult() && resolveMode == ResolveMode.TOP_LEVEL_CALL) { + if (results.isSingleResult() && contextDependency == ContextDependency.INDEPENDENT) { if (!CallResolverUtil.hasInferredReturnType(results.getResultingCall())) { return null; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTask.java index e2897cca844..1e5f96a36c5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTask.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTask.java @@ -46,11 +46,11 @@ public class ResolutionTask extends C public ResolutionTask( @NotNull Collection> candidates, @NotNull JetReferenceExpression reference, @NotNull TracingStrategy tracing, BindingTrace trace, JetScope scope, Call call, JetType expectedType, - DataFlowInfo dataFlowInfo, ResolveMode resolveMode, CheckValueArgumentsMode checkArguments, + DataFlowInfo dataFlowInfo, ContextDependency contextDependency, CheckValueArgumentsMode checkArguments, ExpressionPosition expressionPosition, ResolutionResultsCache resolutionResultsCache, @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments ) { - super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache, + super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, expressionPosition, resolutionResultsCache, dataFlowInfoForArguments); this.candidates = candidates; this.reference = reference; @@ -65,7 +65,7 @@ public class ResolutionTask extends C ) { this(candidates, reference, tracing != null ? tracing : TracingStrategyImpl.create(reference, context.call), context.trace, context.scope, context.call, - context.expectedType, context.dataFlowInfo, context.resolveMode, context.checkArguments, + context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments, context.expressionPosition, context.resolutionResultsCache, context.dataFlowInfoForArguments); } @@ -105,11 +105,11 @@ public class ResolutionTask extends C @NotNull DataFlowInfo dataFlowInfo, @NotNull JetType expectedType, @NotNull ExpressionPosition expressionPosition, - @NotNull ResolveMode resolveMode, + @NotNull ContextDependency contextDependency, @NotNull ResolutionResultsCache resolutionResultsCache ) { ResolutionTask newTask = new ResolutionTask( - candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, + candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, expressionPosition, resolutionResultsCache, dataFlowInfoForArguments); newTask.setCheckingStrategy(checkingStrategy); return newTask; @@ -122,7 +122,7 @@ public class ResolutionTask extends C public ResolutionTask replaceCall(@NotNull Call newCall) { return new ResolutionTask( - candidates, reference, tracing, trace, scope, newCall, expectedType, dataFlowInfo, resolveMode, checkArguments, + candidates, reference, tracing, trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, expressionPosition, resolutionResultsCache, dataFlowInfoForArguments); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index 2142865e66c..dffdb857f30 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -152,7 +152,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetTypeInfo visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) { ExpressionTypingContext contextWithNoExpectedType = - context.replaceExpectedType(NO_EXPECTED_TYPE).replaceResolveMode(ResolveMode.TOP_LEVEL_CALL); + context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(ContextDependency.INDEPENDENT); JetExpression left = expression.getLeft(); JetTypeReference right = expression.getRight(); if (right == null) { @@ -914,7 +914,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { else if (OperatorConventions.COMPARISON_OPERATIONS.contains(operationType)) { //we don't complete 'compareTo' call, because we change its result type from 'Int' to 'Boolean' JetTypeInfo typeInfo = getTypeInfoForBinaryCall( - context.scope, OperatorConventions.COMPARE_TO, context.replaceResolveMode(ResolveMode.TOP_LEVEL_CALL), expression); + context.scope, OperatorConventions.COMPARE_TO, context.replaceContextDependency(ContextDependency.INDEPENDENT), expression); dataFlowInfo = typeInfo.getDataFlowInfo(); JetType compareToReturnType = typeInfo.getType(); if (compareToReturnType != null && !ErrorUtils.isErrorType(compareToReturnType)) { @@ -1064,7 +1064,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { CallMaker.makeCallWithExpressions(callElement, receiver, null, operationSign, Collections.singletonList(left)), operationSign, OperatorConventions.CONTAINS); - JetType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context.resolveMode); + JetType containsType = OverloadResolutionResultsUtil.getResultingType(resolutionResult, context.contextDependency); ensureBooleanResult(operationSign, OperatorConventions.CONTAINS, containsType, context); if (left != null) { @@ -1174,7 +1174,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { dataFlowInfo = facade.getTypeInfo(right, contextWithDataFlow).getDataFlowInfo(); } - return JetTypeInfo.create(OverloadResolutionResultsUtil.getResultingType(resolutionResults, context.resolveMode), dataFlowInfo); + return JetTypeInfo.create(OverloadResolutionResultsUtil.getResultingType(resolutionResults, context.contextDependency), dataFlowInfo); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java index 00b328a5f6e..0d534937795 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java @@ -41,7 +41,7 @@ public class ExpressionTypingContext extends ResolutionContext assignmentOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall( scope, name, context.replaceTraceAndCache(temporaryForAssignmentOperation), expression, receiver); JetType assignmentOperationType = OverloadResolutionResultsUtil.getResultingType(assignmentOperationDescriptors, - context.resolveMode); + context.contextDependency); // Check for '+' Name counterpartName = OperatorConventions.BINARY_OPERATION_NAMES.get(OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(operationType)); @@ -252,7 +252,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito context, "trace to check binary operation like '+' for", expression); OverloadResolutionResults binaryOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall( scope, counterpartName, context.replaceTraceAndCache(temporaryForBinaryOperation), expression, receiver); - JetType binaryOperationType = OverloadResolutionResultsUtil.getResultingType(binaryOperationDescriptors, context.resolveMode); + JetType binaryOperationType = OverloadResolutionResultsUtil.getResultingType(binaryOperationDescriptors, context.contextDependency); JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType; if (assignmentOperationDescriptors.isSuccess() && binaryOperationDescriptors.isSuccess()) {