From 180149b1c17ec0eac3d0a07349be084309810f03 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 13 Mar 2013 17:37:17 +0400 Subject: [PATCH] added ResolutionResultsCache all resolution results are written to it instead of trace --- .../jet/lang/resolve/BindingContext.java | 3 - .../jet/lang/resolve/BindingContextUtils.java | 13 +-- .../resolve/calls/ArgumentTypeResolver.java | 7 +- .../resolve/calls/CallExpressionResolver.java | 51 ++++++----- .../jet/lang/resolve/calls/CallResolver.java | 52 +++++------ .../lang/resolve/calls/CallTransformer.java | 3 +- .../lang/resolve/calls/CandidateResolver.java | 3 +- .../context/BasicCallResolutionContext.java | 17 ++-- .../CallCandidateResolutionContext.java | 30 ++++--- .../calls/context/CallResolutionContext.java | 7 +- .../calls/context/ResolutionResultsCache.java | 87 +++++++++++++++++++ .../calls/context/TypeInfoForCall.java | 6 +- .../resolve/calls/tasks/ResolutionTask.java | 20 +++-- .../ClosureExpressionsTypingVisitor.java | 3 +- .../expressions/ExpressionTypingContext.java | 8 +- .../expressions/ExpressionTypingUtils.java | 3 +- 16 files changed, 200 insertions(+), 113 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCache.java diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java index d744e2fe381..05cafa70730 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -78,7 +78,6 @@ public interface BindingContext { WritableSlice EXPRESSION_TYPE = new BasicWritableSlice(DO_NOTHING); WritableSlice EXPRESSION_DATA_FLOW_INFO = new BasicWritableSlice(DO_NOTHING); WritableSlice DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice(); - WritableSlice> DEFERRED_COMPUTATION_FOR_CALL = Slices.createSimpleSlice(); WritableSlice REFERENCE_TARGET = new BasicWritableSlice(DO_NOTHING); @@ -89,8 +88,6 @@ public interface BindingContext { WritableSlice> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice>(DO_NOTHING); - WritableSlice> RESOLUTION_RESULTS_FOR_FUNCTION = Slices.createSimpleSlice(); - WritableSlice> RESOLUTION_RESULTS_FOR_PROPERTY = Slices.createSimpleSlice(); WritableSlice TRACE_DELTAS_CACHE = Slices.createSimpleSlice(); WritableSlice> LOOP_RANGE_ITERATOR_RESOLVED_CALL = Slices.createSimpleSlice(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java index ed425e0f8b5..8c1fdb40933 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java @@ -25,6 +25,8 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext; +import org.jetbrains.jet.lang.resolve.calls.context.ResolutionResultsCache; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -276,17 +278,6 @@ public class BindingContextUtils { trace.report(AMBIGUOUS_LABEL.on(targetLabel)); } - public static void commitResolutionCacheData(@NotNull DelegatingBindingTrace trace, @NotNull BindingTrace traceForResolutionCache) { - trace.addAllMyDataTo(traceForResolutionCache, new TraceEntryFilter() { - @Override - public boolean accept(@NotNull WritableSlice slice, Object key) { - return slice == BindingContext.RESOLUTION_RESULTS_FOR_FUNCTION || - slice == BindingContext.RESOLUTION_RESULTS_FOR_PROPERTY || - slice == BindingContext.TRACE_DELTAS_CACHE; - } - }, false); - } - public static void recordExpressionType( @NotNull JetExpression expression, @NotNull BindingTrace trace, @NotNull JetScope resolutionScope, @NotNull JetTypeInfo result 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 785aa08b403..a24716c6770 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 @@ -187,17 +187,18 @@ public class ArgumentTypeResolver { if (expression instanceof JetCallExpression) { result = callExpressionResolver.getCallExpressionTypeInfoForCall( (JetCallExpression) expression, ReceiverValue.NO_RECEIVER, null, - context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE), ResolveMode.NESTED_CALL); + context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE), ResolveMode.NESTED_CALL, context.resolutionResultsCache); } else { // expression instanceof JetQualifiedExpression result = callExpressionResolver.getQualifiedExpressionExtendedTypeInfo( - (JetQualifiedExpression) expression, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE), ResolveMode.NESTED_CALL); + (JetQualifiedExpression) expression, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE), + ResolveMode.NESTED_CALL, context.resolutionResultsCache); } recordExpressionType(expression, context.trace, context.scope, result.getTypeInfo()); CallCandidateResolutionContext deferredContext = result.getCallCandidateResolutionContext(); if (deferredContext != null) { - context.trace.record(BindingContext.DEFERRED_COMPUTATION_FOR_CALL, expression, deferredContext); + context.resolutionResultsCache.recordDeferredComputationForCall(expression, deferredContext); } if (traceToCommitForCall != null) { traceToCommitForCall.commit(); 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 e767085e6c8..0f1149542cb 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,6 +24,7 @@ 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.TraceUtil; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.context.*; import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem; @@ -173,11 +174,12 @@ public class CallExpressionResolver { @Nullable private ResolvedCallWithTrace getResolvedCallForFunction( @NotNull Call call, @NotNull JetExpression callExpression, @NotNull ReceiverValue receiver, - @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, @NotNull boolean[] result + @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache, @NotNull boolean[] result ) { CallResolver callResolver = expressionTypingServices.getCallResolver(); OverloadResolutionResultsImpl results = callResolver.resolveFunctionCall( - BasicCallResolutionContext.create(context, call, resolveMode)); + BasicCallResolutionContext.create(context, call, resolveMode, resolutionResultsCache)); if (!results.isNothing()) { checkSuper(receiver, results, context.trace, callExpression); result[0] = true; @@ -205,7 +207,8 @@ public class CallExpressionResolver { 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)); + BasicCallResolutionContext.create(context.replaceBindingTrace(traceForVariable), call, ResolveMode.TOP_LEVEL_CALL, + ResolutionResultsCache.create())); if (!resolutionResult.isNothing()) { traceForVariable.commit(); checkSuper(receiver, resolutionResult, context.trace, nameExpression); @@ -252,7 +255,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); - ResolvedCall resolvedCall = getResolvedCallForFunction(call, nameExpression, receiver, context, ResolveMode.TOP_LEVEL_CALL, result); + ResolvedCall resolvedCall = getResolvedCallForFunction( + call, nameExpression, receiver, context, ResolveMode.TOP_LEVEL_CALL, + ResolutionResultsCache.create(), result); if (result[0]) { FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null; traceForFunction.commit(); @@ -269,16 +274,18 @@ public class CallExpressionResolver { @NotNull public JetTypeInfo getCallExpressionTypeInfo(@NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context) { - return getCallExpressionTypeInfoForCall(callExpression, receiver, callOperationNode, context, ResolveMode.TOP_LEVEL_CALL).getTypeInfo(); + return getCallExpressionTypeInfoForCall(callExpression, receiver, callOperationNode, context, ResolveMode.TOP_LEVEL_CALL, + ResolutionResultsCache.create()).getTypeInfo(); } @NotNull - public TypeInfoForCall getCallExpressionTypeInfoForCall( + public TypeInfoForCall getCallExpressionTypeInfoForCall( @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, - @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode + @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache ) { - TypeInfoForCall typeInfoForCall = getCallExpressionTypeInfoForCallWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, - context, resolveMode); + TypeInfoForCall typeInfoForCall = getCallExpressionTypeInfoForCallWithoutFinalTypeCheck( + callExpression, receiver, callOperationNode, context, resolveMode, resolutionResultsCache); if (resolveMode == ResolveMode.TOP_LEVEL_CALL) { DataFlowUtils.checkType(typeInfoForCall.getType(), callExpression, context, typeInfoForCall.getDataFlowInfo()); } @@ -286,16 +293,17 @@ public class CallExpressionResolver { } @NotNull - public TypeInfoForCall getCallExpressionTypeInfoForCallWithoutFinalTypeCheck( + public TypeInfoForCall getCallExpressionTypeInfoForCallWithoutFinalTypeCheck( @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, - @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode + @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache ) { 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, receiver, context.replaceBindingTrace(traceForFunction), resolveMode, result); + call, callExpression, receiver, context.replaceBindingTrace(traceForFunction), resolveMode, resolutionResultsCache, result); if (result[0]) { FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null; traceForFunction.commit(); @@ -309,7 +317,7 @@ public class CallExpressionResolver { } JetType type = functionDescriptor.getReturnType(); - return TypeInfoForCall.create(type, resolvedCall.getDataFlowInfo(), resolvedCall, call, context, resolveMode); + return TypeInfoForCall.create(type, resolvedCall.getDataFlowInfo(), resolvedCall, call, context, resolveMode, resolutionResultsCache); } JetExpression calleeExpression = callExpression.getCalleeExpression(); @@ -348,11 +356,12 @@ public class CallExpressionResolver { @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ResolutionContext context, - @NotNull ResolveMode resolveMode + @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache ) { if (selectorExpression instanceof JetCallExpression) { return getCallExpressionTypeInfoForCallWithoutFinalTypeCheck((JetCallExpression) selectorExpression, receiver, - callOperationNode, context, resolveMode); + callOperationNode, context, resolveMode, resolutionResultsCache); } else if (selectorExpression instanceof JetSimpleNameExpression) { return TypeInfoForCall.create( @@ -362,7 +371,7 @@ public class CallExpressionResolver { JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression; JetExpression newReceiverExpression = qualifiedExpression.getReceiverExpression(); TypeInfoForCall newReceiverTypeInfo = getSelectorReturnTypeInfo( - receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE), resolveMode); + receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE), resolveMode, resolutionResultsCache); JetType newReceiverType = newReceiverTypeInfo.getType(); DataFlowInfo newReceiverDataFlowInfo = newReceiverTypeInfo.getDataFlowInfo(); JetExpression newSelectorExpression = qualifiedExpression.getSelectorExpression(); @@ -370,7 +379,7 @@ public class CallExpressionResolver { ExpressionReceiver expressionReceiver = new ExpressionReceiver(newReceiverExpression, newReceiverType); return getSelectorReturnTypeInfo( expressionReceiver, qualifiedExpression.getOperationTokenNode(), - newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo), resolveMode); + newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo), resolveMode, resolutionResultsCache); } } else { @@ -381,12 +390,13 @@ public class CallExpressionResolver { @NotNull public JetTypeInfo getQualifiedExpressionTypeInfo(@NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context) { - return getQualifiedExpressionExtendedTypeInfo(expression, context, ResolveMode.TOP_LEVEL_CALL).getTypeInfo(); + return getQualifiedExpressionExtendedTypeInfo(expression, context, ResolveMode.TOP_LEVEL_CALL, ResolutionResultsCache.create()).getTypeInfo(); } @NotNull public TypeInfoForCall getQualifiedExpressionExtendedTypeInfo( - @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode + @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache ) { // TODO : functions as values JetExpression selectorExpression = expression.getSelectorExpression(); @@ -404,7 +414,8 @@ public class CallExpressionResolver { } TypeInfoForCall selectorReturnTypeInfo = getSelectorReturnTypeInfo( - new ExpressionReceiver(receiverExpression, receiverType), expression.getOperationTokenNode(), selectorExpression, context, resolveMode); + new ExpressionReceiver(receiverExpression, receiverType), + expression.getOperationTokenNode(), selectorExpression, context, resolveMode, resolutionResultsCache); JetType selectorReturnType = selectorReturnTypeInfo.getType(); //TODO move further 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 c0957165038..b2b6181d7b0 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 @@ -26,10 +26,7 @@ import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorUtil; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext; -import org.jetbrains.jet.lang.resolve.calls.context.CallCandidateResolutionContext; -import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition; -import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode; +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.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace; @@ -47,7 +44,6 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; -import org.jetbrains.jet.util.slicedmap.WritableSlice; import javax.inject.Inject; import java.util.*; @@ -106,8 +102,8 @@ public class CallResolver { List> prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, referencedName, nameExpression, callableDescriptorCollectors); - return doResolveCallOrGetCachedResults(RESOLUTION_RESULTS_FOR_PROPERTY, context, prioritizedTasks, - CallTransformer.PROPERTY_CALL_TRANSFORMER, nameExpression); + return doResolveCallOrGetCachedResults(ResolutionResultsCache.PROPERTY_MEMBER_TYPE, + context, prioritizedTasks, CallTransformer.PROPERTY_CALL_TRANSFORMER, nameExpression); } @NotNull @@ -117,8 +113,8 @@ public class CallResolver { @NotNull Name name) { List> tasks = TaskPrioritizer.computePrioritizedTasks(context, name, functionReference, CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES); - return doResolveCallOrGetCachedResults(RESOLUTION_RESULTS_FOR_FUNCTION, context, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, - functionReference); + return doResolveCallOrGetCachedResults(ResolutionResultsCache.FUNCTION_MEMBER_TYPE, + context, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, functionReference); } @NotNull @@ -129,7 +125,9 @@ public class CallResolver { @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo ) { - return resolveFunctionCall(BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, ResolveMode.TOP_LEVEL_CALL, ExpressionPosition.FREE)); + return resolveFunctionCall(BasicCallResolutionContext.create( + trace, scope, call, expectedType, dataFlowInfo, ResolveMode.TOP_LEVEL_CALL, ExpressionPosition.FREE, + ResolutionResultsCache.create())); } @NotNull @@ -256,14 +254,14 @@ public class CallResolver { } } - return doResolveCallOrGetCachedResults(RESOLUTION_RESULTS_FOR_FUNCTION, context, prioritizedTasks, + return doResolveCallOrGetCachedResults(ResolutionResultsCache.FUNCTION_MEMBER_TYPE, context, prioritizedTasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, functionReference); } private OverloadResolutionResultsImpl doResolveCallOrGetCachedResults( - @NotNull WritableSlice> resolutionResultsSlice, - @NotNull BasicCallResolutionContext context, - @NotNull List> prioritizedTasks, + @NotNull ResolutionResultsCache.MemberType memberType, + @NotNull final BasicCallResolutionContext context, + @NotNull final List> prioritizedTasks, @NotNull CallTransformer callTransformer, @NotNull JetReferenceExpression reference ) { @@ -272,9 +270,9 @@ public class CallResolver { TemporaryBindingTrace traceToResolveCall = TemporaryBindingTrace.create(context.trace, "trace to resolve call", context.call); if (element instanceof JetExpression) { CallKey key = CallKey.create(context.call.getCallType(), (JetExpression) element); - OverloadResolutionResultsImpl cachedResults = context.trace.get(resolutionResultsSlice, key); + OverloadResolutionResultsImpl cachedResults = context.resolutionResultsCache.getResolutionResults(key, memberType); if (cachedResults != null) { - DelegatingBindingTrace deltasTraceForResolve = context.trace.get(TRACE_DELTAS_CACHE, (JetExpression) element); + DelegatingBindingTrace deltasTraceForResolve = context.resolutionResultsCache.getResolutionTrace((JetExpression) element); assert deltasTraceForResolve != null; deltasTraceForResolve.addAllMyDataTo(traceToResolveCall); results = cachedResults; @@ -288,7 +286,7 @@ public class CallResolver { deltasTraceForTypeInference.addAllMyDataTo(traceToResolveCall); } completeTypeInferenceDependentOnFunctionLiterals(newContext, results, TracingStrategy.EMPTY); - cacheResults(resolutionResultsSlice, context, results, traceToResolveCall); + cacheResults(memberType, context, results, traceToResolveCall); } traceToResolveCall.commit(); @@ -351,16 +349,10 @@ public class CallResolver { return OverloadResolutionResultsImpl.incompleteTypeInference(copy); } - private void cacheResults(@NotNull WritableSlice> resolutionResultsSlice, + private static void cacheResults( + @NotNull ResolutionResultsCache.MemberType memberType, @NotNull BasicCallResolutionContext context, @NotNull OverloadResolutionResultsImpl results, @NotNull DelegatingBindingTrace traceToResolveCall) { - //boolean canBeCached = true; - //for (ResolvedCall call : results.getResultingCalls()) { - // if (!call.getCandidateDescriptor().getTypeParameters().isEmpty()) { - // canBeCached = false; - // } - //} - //if (!canBeCached) return; PsiElement callElement = context.call.getCallElement(); if (!(callElement instanceof JetExpression)) return; @@ -368,9 +360,9 @@ public class CallResolver { new BindingTraceContext().getBindingContext(), "delta trace for caching resolve of", context.call); traceToResolveCall.addAllMyDataTo(deltasTraceToCacheResolve); - - context.trace.record(resolutionResultsSlice, CallKey.create(context.call.getCallType(), (JetExpression) callElement), results); - context.trace.record(TRACE_DELTAS_CACHE, (JetExpression) callElement, deltasTraceToCacheResolve); + context.resolutionResultsCache.recordResolutionResults( + CallKey.create(context.call.getCallType(), (JetExpression) callElement), memberType, results); + context.resolutionResultsCache.recordResolutionTrace((JetExpression) callElement, deltasTraceToCacheResolve); } private OverloadResolutionResultsImpl checkArgumentTypesAndFail(BasicCallResolutionContext context) { @@ -489,7 +481,7 @@ public class CallResolver { public List getFunctionLiteralArguments() { return Collections.emptyList(); } - }, task.expectedType, task.dataFlowInfo, task.resolveMode, task.expressionPosition); + }, task.expectedType, task.dataFlowInfo, task.resolveMode, task.expressionPosition, task.resolutionResultsCache); OverloadResolutionResultsImpl resultsWithFunctionLiteralsStripped = performResolution(newTask, callTransformer, traceForResolutionCache); if (resultsWithFunctionLiteralsStripped.isSuccess() || resultsWithFunctionLiteralsStripped.isAmbiguity()) { task.tracing.danglingFunctionLiteralArgumentSuspected(task.trace, task.call.getFunctionLiteralArguments()); @@ -524,8 +516,6 @@ public class CallResolver { task.tracing.bindResolvedCall(call.getTrace(), call); task.getResolvedCalls().add(call); } - - BindingContextUtils.commitResolutionCacheData(context.candidateCall.getTrace(), traceForResolutionCache); } } 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 0a89cc347f8..4b4e27c1c36 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 @@ -193,7 +193,8 @@ public class CallTransformer { DelegatingBindingTrace variableCallTrace = context.candidateCall.getTrace(); BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create( - variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo, context.resolveMode, context.expressionPosition); + variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo, + context.resolveMode, 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 b90ede63dc9..2f0b7d19d99 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 @@ -291,7 +291,7 @@ public class CandidateResolver { : effectiveExpectedType; CallCandidateResolutionContext storedContextForArgument = - context.trace.get(BindingContext.DEFERRED_COMPUTATION_FOR_CALL, expression); + context.resolutionResultsCache.getDeferredComputation(expression); if (storedContextForArgument == null) continue; CallCandidateResolutionContext contextForArgument = @@ -358,7 +358,6 @@ public class CandidateResolver { traceToResolveFunctionLiteral.commit(); return; } - BindingContextUtils.commitResolutionCacheData(traceToResolveFunctionLiteral, context.trace); } JetType expectedTypeWithoutReturnType = hasExpectedReturnType ? CallResolverUtil.replaceReturnTypeByUnknown(expectedType) : expectedType; CallCandidateResolutionContext newContext = context.replaceExpectedType(expectedTypeWithoutReturnType); 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 ada7c4f187b..e6fb9510aec 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 @@ -32,20 +32,23 @@ public class BasicCallResolutionContext extends CallResolutionContext @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull ResolveMode resolveMode, - @NotNull ExpressionPosition expressionPosition + @NotNull ExpressionPosition expressionPosition, + @NotNull ResolutionResultsCache resolutionResultsCache ) { - super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition); + super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, resolutionResultsCache); this.candidateCall = candidateCall; this.tracing = tracing; } public static CallCandidateResolutionContext create( - @NotNull ResolvedCallImpl candidateCall, @NotNull CallResolutionContext context, @NotNull BindingTrace trace, + @NotNull ResolvedCallImpl candidateCall, @NotNull CallResolutionContext context, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) { candidateCall.setInitialDataFlowInfo(context.dataFlowInfo); - return new CallCandidateResolutionContext(candidateCall, tracing, trace, context.scope, call, context.expectedType, - context.dataFlowInfo, context.resolveMode, context.expressionPosition); + return new CallCandidateResolutionContext( + candidateCall, tracing, trace, context.scope, call, context.expectedType, + context.dataFlowInfo, context.resolveMode, context.expressionPosition, context.resolutionResultsCache); } public static CallCandidateResolutionContext create( - @NotNull ResolvedCallImpl candidateCall, @NotNull CallResolutionContext context, @NotNull BindingTrace trace, + @NotNull ResolvedCallImpl candidateCall, @NotNull CallResolutionContext context, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) { return create(candidateCall, context, trace, tracing, context.call); } @@ -66,15 +67,16 @@ 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, tracing); + return createForCallBeingAnalyzed(candidateCall, context, context.call, context.resolveMode, tracing, context.resolutionResultsCache); } public static CallCandidateResolutionContext createForCallBeingAnalyzed( @NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionContext context, @NotNull Call call, - @NotNull ResolveMode resolveMode, @NotNull TracingStrategy tracing + @NotNull ResolveMode resolveMode, @NotNull TracingStrategy tracing, @NotNull ResolutionResultsCache resolutionResultsCache ) { - return new CallCandidateResolutionContext(candidateCall, tracing, context.trace, context.scope, call, - context.expectedType, context.dataFlowInfo, resolveMode, context.expressionPosition); + return new CallCandidateResolutionContext( + candidateCall, tracing, context.trace, context.scope, call, context.expectedType, + context.dataFlowInfo, resolveMode, context.expressionPosition, resolutionResultsCache); } @Override @@ -86,7 +88,8 @@ public final class CallCandidateResolutionContext @NotNull ExpressionPosition expressionPosition ) { return new CallCandidateResolutionContext( - candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition); + candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, + resolutionResultsCache); } @Override @@ -98,6 +101,7 @@ public final class CallCandidateResolutionContext public CallCandidateResolutionContext replaceResolveMode(@NotNull ResolveMode newResolveMode) { if (newResolveMode == resolveMode) return this; return new CallCandidateResolutionContext( - candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, newResolveMode, expressionPosition); + candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, newResolveMode, 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 16129204031..1c1c185f6dc 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 @@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.types.JetType; public abstract class CallResolutionContext extends ResolutionContext { public final Call call; public final ResolveMode resolveMode; + public final ResolutionResultsCache resolutionResultsCache; protected CallResolutionContext( @NotNull BindingTrace trace, @@ -34,14 +35,16 @@ public abstract class CallResolutionContext {} + private static class FunctionMemberType extends MemberType {} + private static class PropertyMemberType extends MemberType {} + public static final FunctionMemberType FUNCTION_MEMBER_TYPE = new FunctionMemberType(); + public static final PropertyMemberType PROPERTY_MEMBER_TYPE = new PropertyMemberType(); + + + private static final WritableSlice> RESOLUTION_RESULTS_FOR_FUNCTION = Slices.createSimpleSlice(); + private static final WritableSlice> RESOLUTION_RESULTS_FOR_PROPERTY = Slices.createSimpleSlice(); + private static final WritableSlice TRACE_DELTAS_CACHE = Slices.createSimpleSlice(); + private static final WritableSlice> DEFERRED_COMPUTATION_FOR_CALL = Slices.createSimpleSlice(); + + private final BindingTrace trace = new BindingTraceContext(); + + @NotNull + private static WritableSlice> getSliceByMemberType(@NotNull MemberType memberType) { + return (WritableSlice>) + (memberType == FUNCTION_MEMBER_TYPE ? RESOLUTION_RESULTS_FOR_FUNCTION : RESOLUTION_RESULTS_FOR_PROPERTY); + } + + public void recordResolutionResults(@NotNull CallKey callKey, @NotNull MemberType memberType, @NotNull OverloadResolutionResultsImpl results) { + trace.record(getSliceByMemberType(memberType), callKey, results); + } + + @Nullable + public OverloadResolutionResultsImpl getResolutionResults(@NotNull CallKey callKey, @NotNull MemberType memberType) { + return trace.get(getSliceByMemberType(memberType), callKey); + } + + public void recordResolutionTrace(@NotNull JetExpression expression, @NotNull DelegatingBindingTrace delegatingTrace) { + trace.record(TRACE_DELTAS_CACHE, expression, delegatingTrace); + } + + @Nullable + public DelegatingBindingTrace getResolutionTrace(@NotNull JetExpression expression) { + return trace.get(TRACE_DELTAS_CACHE, expression); + } + + public void recordDeferredComputationForCall(@NotNull JetExpression expression, @NotNull CallCandidateResolutionContext deferredComputation) { + trace.record(DEFERRED_COMPUTATION_FOR_CALL, expression, deferredComputation); + } + + @Nullable + public CallCandidateResolutionContext getDeferredComputation(@NotNull JetExpression expression) { + return trace.get(DEFERRED_COMPUTATION_FOR_CALL, expression); + } + + @NotNull + public static ResolutionResultsCache create() { + return new ResolutionResultsCache(); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java index 7e2e4cb0444..a3d77707b59 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java @@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.psi.Call; +import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.TraceUtil; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl; @@ -48,13 +49,14 @@ public class TypeInfoForCall { @NotNull ResolvedCallWithTrace resolvedCall, @NotNull Call call, @NotNull ResolutionContext context, - @NotNull ResolveMode resolveMode + @NotNull ResolveMode resolveMode, + @NotNull ResolutionResultsCache resolutionResultsCache ) { JetTypeInfo typeInfo = JetTypeInfo.create(type, dataFlowInfo); ResolvedCallImpl resolvedCallToComplete = resolvedCall.getCallToCompleteTypeArgumentInference(); CallCandidateResolutionContext callCandidateResolutionContext = createForCallBeingAnalyzed( resolvedCallToComplete, context.replaceBindingTrace(TraceUtil.TRACE_STUB), - call, resolveMode, resolvedCallToComplete.getTracing()); + call, resolveMode, resolvedCallToComplete.getTracing(), resolutionResultsCache); return new TypeInfoForCall(typeInfo, callCandidateResolutionContext); } 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 6ad80878633..68f36b55a77 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 @@ -23,10 +23,7 @@ import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext; -import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext; -import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition; -import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode; +import org.jetbrains.jet.lang.resolve.calls.context.*; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; @@ -45,16 +42,19 @@ public class ResolutionTask extends C public final TracingStrategy tracing; public ResolutionTask( - @NotNull Collection> candidates, @NotNull JetReferenceExpression reference, @NotNull TracingStrategy tracing, - BindingTrace trace, JetScope scope, Call call, JetType expectedType, DataFlowInfo dataFlowInfo, ResolveMode resolveMode, ExpressionPosition expressionPosition) { - super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition); + @NotNull Collection> candidates, @NotNull JetReferenceExpression reference, + @NotNull TracingStrategy tracing, BindingTrace trace, JetScope scope, Call call, JetType expectedType, + DataFlowInfo dataFlowInfo, ResolveMode resolveMode, ExpressionPosition expressionPosition, ResolutionResultsCache resolutionResultsCache + ) { + super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, resolutionResultsCache); this.candidates = candidates; this.reference = reference; this.tracing = tracing; } public ResolutionTask(@NotNull Collection> candidates, @NotNull JetReferenceExpression reference, @NotNull BasicCallResolutionContext context) { - this(candidates, reference, TracingStrategyImpl.create(reference, context.call), context.trace, context.scope, context.call, context.expectedType, context.dataFlowInfo, context.resolveMode, context.expressionPosition); + this(candidates, reference, TracingStrategyImpl.create(reference, context.call), context.trace, context.scope, context.call, + context.expectedType, context.dataFlowInfo, context.resolveMode, context.expressionPosition, context.resolutionResultsCache); } @NotNull @@ -86,7 +86,9 @@ public class ResolutionTask extends C @NotNull JetType expectedType, @NotNull ExpressionPosition expressionPosition ) { - ResolutionTask newTask = new ResolutionTask(candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition); + ResolutionTask newTask = new ResolutionTask( + candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, + resolutionResultsCache); newTask.setCheckingStrategy(checkingStrategy); return newTask; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index de289435cda..8b60f473f9b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -247,8 +247,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { temporaryTrace.commit(new TraceEntryFilter() { @Override public boolean accept(@NotNull WritableSlice slice, Object key) { - return (slice != BindingContext.RESOLUTION_RESULTS_FOR_FUNCTION && slice != BindingContext.RESOLUTION_RESULTS_FOR_PROPERTY && - slice != BindingContext.TRACE_DELTAS_CACHE); + return (slice != BindingContext.TRACE_DELTAS_CACHE); } }, true); 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 388dd08d214..5d96d1f29cd 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 @@ -21,11 +21,9 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.TraceUtil; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext; -import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition; -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.context.*; import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver; import org.jetbrains.jet.lang.resolve.name.Name; @@ -107,6 +105,6 @@ 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), functionReference, name); + BasicCallResolutionContext.create(this, call, ResolveMode.TOP_LEVEL_CALL, ResolutionResultsCache.create()), functionReference, name); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 1042cb88c9e..6daa8c74ec0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -319,8 +319,7 @@ public class ExpressionTypingUtils { @Override public boolean accept(@NotNull WritableSlice slice, Object key) { // excluding all entries related to fake expression - // keys in RESOLUTION_RESULTS_FOR_FUNCTION slice have fake expression inside - return key != fake && slice != RESOLUTION_RESULTS_FOR_FUNCTION; + return key != fake; } }, false); }