From 543e0343c57ffc471074aa95fd2333be2d687ec9 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Thu, 20 Jun 2013 18:53:59 +0400 Subject: [PATCH] moved ResolveMode, ResolutionResultsCache from CallResolutionContext to ResolutionContext --- .../jet/lang/resolve/BodyResolver.java | 9 ++-- .../resolve/calls/CallExpressionResolver.java | 48 ++++++++----------- .../context/BasicCallResolutionContext.java | 13 +++-- .../CallCandidateResolutionContext.java | 12 ++--- .../calls/context/CallResolutionContext.java | 8 +--- .../calls/context/ResolutionContext.java | 39 ++++++++++++--- .../context/SimpleResolutionContext.java | 12 +++-- .../resolve/calls/tasks/ResolutionTask.java | 4 +- .../BasicExpressionTypingVisitor.java | 13 +++-- .../expressions/ExpressionTypingContext.java | 42 +++++++++++----- .../expressions/ExpressionTypingServices.java | 10 +++- .../ExpressionTypingVisitorForStatements.java | 7 +-- 12 files changed, 132 insertions(+), 85 deletions(-) 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 050fd16f9ba..b6e15ad2115 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,9 @@ 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.ExpressionPosition; +import org.jetbrains.jet.lang.resolve.calls.context.ResolutionResultsCacheImpl; import org.jetbrains.jet.lang.resolve.calls.context.SimpleResolutionContext; import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition; import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem; @@ -213,9 +215,10 @@ public class BodyResolver { : scopeForConstructor; JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, context.getOuterDataFlowInfo(), trace); if (type != null && supertype != null) { - DataFlowUtils.checkType(type, delegateExpression, - new SimpleResolutionContext(trace, scope, supertype, context.getOuterDataFlowInfo(), - ExpressionPosition.FREE)); + SimpleResolutionContext simpleResolutionContext = new SimpleResolutionContext( + trace, scope, supertype, context.getOuterDataFlowInfo(), ExpressionPosition.FREE, ResolveMode.NORMAL, + ResolutionResultsCacheImpl.create()); + DataFlowUtils.checkType(type, delegateExpression, simpleResolutionContext); } } } 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 bd28f643ade..13ba8ac4f11 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 @@ -184,17 +184,16 @@ public class CallExpressionResolver { @Nullable public ResolvedCallWithTrace getResolvedCallForFunction( @NotNull Call call, @NotNull JetExpression callExpression, - @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, - @NotNull CheckValueArgumentsMode checkArguments, @NotNull ResolutionResultsCache resolutionResultsCache, + @NotNull ResolutionContext context, @NotNull CheckValueArgumentsMode checkArguments, @NotNull boolean[] result ) { CallResolver callResolver = expressionTypingServices.getCallResolver(); OverloadResolutionResultsImpl results = callResolver.resolveFunctionCall( - BasicCallResolutionContext.create(context, call, resolveMode, checkArguments, resolutionResultsCache)); + BasicCallResolutionContext.create(context, call, checkArguments)); if (!results.isNothing()) { checkSuper(call.getExplicitReceiver(), results, context.trace, callExpression); result[0] = true; - if (results.isSingleResult() && resolveMode == ResolveMode.TOP_LEVEL_CALL) { + if (results.isSingleResult() && context.resolveMode == ResolveMode.TOP_LEVEL_CALL) { if (!CallResolverUtil.hasInferredReturnType(results.getResultingCall())) return null; } @@ -212,9 +211,10 @@ public class CallExpressionResolver { context.trace, "trace to resolve as local variable or property", nameExpression); CallResolver callResolver = expressionTypingServices.getCallResolver(); Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression); - OverloadResolutionResults resolutionResult = callResolver.resolveSimpleProperty( - BasicCallResolutionContext.create(context.replaceBindingTrace(traceForVariable), call, ResolveMode.TOP_LEVEL_CALL, - CheckValueArgumentsMode.ENABLED, ResolutionResultsCache.create())); + BasicCallResolutionContext contextForVariable = BasicCallResolutionContext.create( + context.replaceBindingTrace(traceForVariable).replaceResolveMode(ResolveMode.TOP_LEVEL_CALL). + replaceResolutionResultsCache(), call, CheckValueArgumentsMode.ENABLED); + OverloadResolutionResults resolutionResult = callResolver.resolveSimpleProperty(contextForVariable); if (!resolutionResult.isNothing()) { traceForVariable.commit(); checkSuper(receiver, resolutionResult, context.trace, nameExpression); @@ -261,9 +261,9 @@ public class CallExpressionResolver { Call call = CallMaker.makeCall(nameExpression, receiver, callOperationNode, nameExpression, Collections.emptyList()); TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function", nameExpression); + ResolutionContext newContext = context.replaceResolveMode(ResolveMode.TOP_LEVEL_CALL).replaceResolutionResultsCache(); ResolvedCall resolvedCall = getResolvedCallForFunction( - call, nameExpression, context, ResolveMode.TOP_LEVEL_CALL, CheckValueArgumentsMode.ENABLED, - ResolutionResultsCache.create(), result); + call, nameExpression, newContext, CheckValueArgumentsMode.ENABLED, result); if (result[0]) { FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null; traceForFunction.commit(); @@ -280,12 +280,11 @@ public class CallExpressionResolver { @NotNull public JetTypeInfo getCallExpressionTypeInfo( @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, - @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, - @NotNull ResolutionResultsCache resolutionResultsCache + @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context ) { JetTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck( - callExpression, receiver, callOperationNode, context, resolveMode, resolutionResultsCache); - if (resolveMode == ResolveMode.TOP_LEVEL_CALL) { + callExpression, receiver, callOperationNode, context); + if (context.resolveMode == ResolveMode.TOP_LEVEL_CALL) { DataFlowUtils.checkType(typeInfo.getType(), callExpression, context, typeInfo.getDataFlowInfo()); } return typeInfo; @@ -294,16 +293,14 @@ public class CallExpressionResolver { @NotNull public JetTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck( @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, - @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, - @NotNull ResolutionResultsCache resolutionResultsCache + @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context ) { boolean[] result = new boolean[1]; Call call = CallMaker.makeCall(receiver, callOperationNode, callExpression); TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function call", callExpression); ResolvedCallWithTrace resolvedCall = getResolvedCallForFunction( - call, callExpression, context.replaceBindingTrace(traceForFunction), resolveMode, CheckValueArgumentsMode.ENABLED, - resolutionResultsCache, result); + call, callExpression, context.replaceBindingTrace(traceForFunction), CheckValueArgumentsMode.ENABLED, result); if (result[0]) { FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null; traceForFunction.commit(); @@ -355,13 +352,11 @@ public class CallExpressionResolver { @NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, - @NotNull ResolutionContext context, - @NotNull ResolveMode resolveMode, - @NotNull ResolutionResultsCache resolutionResultsCache + @NotNull ResolutionContext context ) { if (selectorExpression instanceof JetCallExpression) { return getCallExpressionTypeInfoWithoutFinalTypeCheck((JetCallExpression) selectorExpression, receiver, - callOperationNode, context, resolveMode, resolutionResultsCache); + callOperationNode, context); } else if (selectorExpression instanceof JetSimpleNameExpression) { return getSimpleNameExpressionTypeInfo((JetSimpleNameExpression) selectorExpression, receiver, callOperationNode, context); @@ -370,7 +365,7 @@ public class CallExpressionResolver { JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression; JetExpression newReceiverExpression = qualifiedExpression.getReceiverExpression(); JetTypeInfo newReceiverTypeInfo = getSelectorReturnTypeInfo( - receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE), resolveMode, resolutionResultsCache); + receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE)); JetType newReceiverType = newReceiverTypeInfo.getType(); DataFlowInfo newReceiverDataFlowInfo = newReceiverTypeInfo.getDataFlowInfo(); JetExpression newSelectorExpression = qualifiedExpression.getSelectorExpression(); @@ -378,7 +373,7 @@ public class CallExpressionResolver { ExpressionReceiver expressionReceiver = new ExpressionReceiver(newReceiverExpression, newReceiverType); return getSelectorReturnTypeInfo( expressionReceiver, qualifiedExpression.getOperationTokenNode(), - newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo), resolveMode, resolutionResultsCache); + newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo)); } } else { @@ -389,8 +384,7 @@ public class CallExpressionResolver { @NotNull public JetTypeInfo getQualifiedExpressionTypeInfo( - @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, - @NotNull ResolutionResultsCache resolutionResultsCache + @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context ) { // TODO : functions as values JetExpression selectorExpression = expression.getSelectorExpression(); @@ -409,7 +403,7 @@ public class CallExpressionResolver { JetTypeInfo selectorReturnTypeInfo = getSelectorReturnTypeInfo( new ExpressionReceiver(receiverExpression, receiverType), - expression.getOperationTokenNode(), selectorExpression, context, resolveMode, resolutionResultsCache); + expression.getOperationTokenNode(), selectorExpression, context); JetType selectorReturnType = selectorReturnTypeInfo.getType(); //TODO move further @@ -426,7 +420,7 @@ public class CallExpressionResolver { context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, selectorReturnType); } JetTypeInfo typeInfo = JetTypeInfo.create(selectorReturnType, selectorReturnTypeInfo.getDataFlowInfo()); - if (resolveMode == ResolveMode.TOP_LEVEL_CALL) { + if (context.resolveMode == ResolveMode.TOP_LEVEL_CALL) { DataFlowUtils.checkType(typeInfo.getType(), expression, context, typeInfo.getDataFlowInfo()); } return typeInfo; 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 c0343251861..65f9addcec7 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 @@ -40,10 +40,10 @@ public class BasicCallResolutionContext extends CallResolutionContext @NotNull JetScope scope, @NotNull DataFlowInfo dataFlowInfo, @NotNull JetType expectedType, - @NotNull ExpressionPosition expressionPosition + @NotNull ExpressionPosition expressionPosition, + @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache ) { return new CallCandidateResolutionContext( candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, @@ -100,12 +102,4 @@ public final class CallCandidateResolutionContext protected CallCandidateResolutionContext self() { return this; } - - @NotNull - public CallCandidateResolutionContext replaceResolveMode(@NotNull ResolveMode newResolveMode) { - if (newResolveMode == resolveMode) return this; - return new CallCandidateResolutionContext( - candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, newResolveMode, - 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 a25c8334a7d..0fc76ad11bc 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 @@ -25,9 +25,7 @@ import org.jetbrains.jet.lang.types.JetType; public abstract class CallResolutionContext> extends ResolutionContext { public final Call call; - public final ResolveMode resolveMode; public final CheckValueArgumentsMode checkArguments; - public final ResolutionResultsCache resolutionResultsCache; protected CallResolutionContext( @NotNull BindingTrace trace, @@ -40,14 +38,12 @@ public abstract class CallResolutionContext extends C @NotNull JetScope scope, @NotNull DataFlowInfo dataFlowInfo, @NotNull JetType expectedType, - @NotNull ExpressionPosition expressionPosition + @NotNull ExpressionPosition expressionPosition, + @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache ) { ResolutionTask newTask = new ResolutionTask( candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, 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 fba564a67b7..980dcbcd986 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 @@ -666,7 +666,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { TemporaryBindingTrace traceWithReceiver = TemporaryBindingTrace.create(context.trace, "trace to resolve callable reference with receiver", reference); FunctionDescriptor descriptor = - resolveCallableNotCheckingArguments(reference, receiver, context.replaceBindingTrace(traceWithReceiver), result); + resolveCallableNotCheckingArguments( + reference, receiver, context.replaceBindingTrace(traceWithReceiver).replaceResolutionResultsCache(), result); if (result[0]) { traceWithReceiver.commit(); return descriptor; @@ -676,7 +677,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { TemporaryBindingTrace traceForStatic = TemporaryBindingTrace.create(context.trace, "trace to resolve callable reference in static scope", reference); FunctionDescriptor possibleStaticNestedClassConstructor = resolveCallableNotCheckingArguments(reference, NO_RECEIVER, - context.replaceBindingTrace(traceForStatic).replaceScope(staticScope), result); + context.replaceBindingTrace(traceForStatic).replaceScope(staticScope).replaceResolutionResultsCache(), result); if (result[0]) { traceForStatic.commit(); return possibleStaticNestedClassConstructor; @@ -698,8 +699,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ExpressionTypingContext contextForResolve = context.replaceBindingTrace(trace).replaceExpectedType(NO_EXPECTED_TYPE); ResolvedCallWithTrace function = contextForResolve.expressionTypingServices.getCallExpressionResolver() - .getResolvedCallForFunction(call, reference, contextForResolve, ResolveMode.TOP_LEVEL_CALL, - CheckValueArgumentsMode.DISABLED, ResolutionResultsCache.create(), result); + .getResolvedCallForFunction(call, reference, contextForResolve, CheckValueArgumentsMode.DISABLED, result); if (!result[0]) return null; if (function instanceof VariableAsFunctionResolvedCall) { @@ -717,14 +717,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { public JetTypeInfo visitQualifiedExpression(JetQualifiedExpression expression, ExpressionTypingContext context) { CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver(); return callExpressionResolver - .getQualifiedExpressionTypeInfo(expression, context, ResolveMode.TOP_LEVEL_CALL, ResolutionResultsCache.create()); + .getQualifiedExpressionTypeInfo(expression, context); } @Override public JetTypeInfo visitCallExpression(JetCallExpression expression, ExpressionTypingContext context) { CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver(); - return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context, ResolveMode.TOP_LEVEL_CALL, - ResolutionResultsCache.create()); + return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context); } @Override 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 d05bb00c3ae..5ce18628641 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 @@ -38,8 +38,20 @@ public class ExpressionTypingContext extends ResolutionContext resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull Name name) { return expressionTypingServices.getCallResolver().resolveCallWithGivenName( - BasicCallResolutionContext.create(this, call, ResolveMode.TOP_LEVEL_CALL, - CheckValueArgumentsMode.ENABLED, ResolutionResultsCache.create()), + BasicCallResolutionContext.create(this, call, CheckValueArgumentsMode.ENABLED), functionReference, name ); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index 6f0dbe648b2..c544c382a0b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition; +import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; @@ -132,6 +133,11 @@ public class ExpressionTypingServices { return expressionTypingFacade.getTypeInfo(expression, context); } + @NotNull + public JetTypeInfo getTypeInfo(@NotNull JetExpression expression, @NotNull ResolutionContext resolutionContext) { + return expressionTypingFacade.getTypeInfo(expression, ExpressionTypingContext.newContext(this, resolutionContext)); + } + @Nullable public JetType getType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) { return getTypeInfo(scope, expression, expectedType, dataFlowInfo, trace).getType(); @@ -324,8 +330,8 @@ public class ExpressionTypingServices { } private ExpressionTypingContext createContext(ExpressionTypingContext oldContext, BindingTrace trace, WritableScope scope, DataFlowInfo dataFlowInfo, JetType expectedType) { - return ExpressionTypingContext.newContext( - this, oldContext.labelResolver, trace, scope, dataFlowInfo, expectedType, oldContext.expressionPosition); + return ExpressionTypingContext.newContext(this, oldContext.labelResolver, trace, scope, dataFlowInfo, expectedType, + oldContext.expressionPosition, oldContext.resolveMode, oldContext.resolutionResultsCache); } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java index bd36e077a57..2682f844498 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java @@ -209,7 +209,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito //There is a temporary binding trace for an opportunity to resolve set method for array if needed (the initial trace should be used there) TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create( contextWithExpectedType.trace, "trace to resolve array set method for binary expression", expression); - ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceBindingTrace(temporaryBindingTrace); + ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE) + .replaceBindingTrace(temporaryBindingTrace).replaceResolutionResultsCache(); JetSimpleNameExpression operationSign = expression.getOperationReference(); IElementType operationType = operationSign.getReferencedNameElementType(); @@ -238,14 +239,14 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito Name name = OperatorConventions.ASSIGNMENT_OPERATIONS.get(operationType); TemporaryBindingTrace assignmentOperationTrace = TemporaryBindingTrace.create(context.trace, "trace to check assignment operation like '+=' for", expression); OverloadResolutionResults assignmentOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall( - scope, name, context.replaceBindingTrace(assignmentOperationTrace), expression, receiver); + scope, name, context.replaceBindingTrace(assignmentOperationTrace).replaceResolutionResultsCache(), expression, receiver); JetType assignmentOperationType = OverloadResolutionResultsUtil.getResultType(assignmentOperationDescriptors); // Check for '+' Name counterpartName = OperatorConventions.BINARY_OPERATION_NAMES.get(OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(operationType)); TemporaryBindingTrace binaryOperationTrace = TemporaryBindingTrace.create(context.trace, "trace to check binary operation like '+' for", expression); OverloadResolutionResults binaryOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall( - scope, counterpartName, context.replaceBindingTrace(binaryOperationTrace), expression, receiver); + scope, counterpartName, context.replaceBindingTrace(binaryOperationTrace).replaceResolutionResultsCache(), expression, receiver); JetType binaryOperationType = OverloadResolutionResultsUtil.getResultType(binaryOperationDescriptors); JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;