diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java index f3586b35230..6bafc5193f2 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java @@ -203,7 +203,7 @@ public final class PsiCodegenPredictor { ) { final Ref resultingDescriptor = Ref.create(); - DelegatingBindingTrace trace = new DelegatingBindingTrace(context) { + DelegatingBindingTrace trace = new DelegatingBindingTrace(context, "trace in PsiCodegenPredictor") { @Override public void record(WritableSlice slice, K key, V value) { super.record(slice, key, value); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java index 19effe34a63..b3241ddb23b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java @@ -91,7 +91,7 @@ public class GenerationState { this.files = files; this.classBuilderMode = builderFactory.getClassBuilderMode(); - bindingTrace = new DelegatingBindingTrace(exhaust.getBindingContext()); + bindingTrace = new DelegatingBindingTrace(exhaust.getBindingContext(), "trace in GenerationState"); bindingContext = bindingTrace.getBindingContext(); this.typeMapper = new JetTypeMapper(bindingTrace, builtinToJavaTypesMapping == BuiltinToJavaTypesMapping.ENABLED, classBuilderMode); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java index 5862c3caa19..3ede95a8df2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java @@ -20,6 +20,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiElementVisitor; import com.intellij.psi.PsiErrorElement; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; @@ -72,4 +73,14 @@ public class AnalyzingUtils { } // -------------------------------------------------------------------------------------------------------------------------- + + public static String formDebugNameForBindingTrace(@NotNull String debugName, @Nullable Object resolutionSubjectForMessage) { + if (resolutionSubjectForMessage instanceof PsiElement) { + resolutionSubjectForMessage = ((PsiElement) resolutionSubjectForMessage).getText(); + } + if (resolutionSubjectForMessage != null) { + return debugName + " '" + resolutionSubjectForMessage + "'"; + } + return debugName; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java index b168498bb7e..38c83475f98 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java @@ -16,17 +16,19 @@ package org.jetbrains.jet.lang.resolve; +import org.jetbrains.annotations.Nullable; + /** * @author svtk */ public class ChainedTemporaryBindingTrace extends TemporaryBindingTrace { - public static ChainedTemporaryBindingTrace create(TemporaryBindingTrace trace) { - return new ChainedTemporaryBindingTrace(trace); + public static ChainedTemporaryBindingTrace create(TemporaryBindingTrace trace, String debugName, @Nullable Object resolutionSubjectForMessage) { + return new ChainedTemporaryBindingTrace(trace, AnalyzingUtils.formDebugNameForBindingTrace(debugName, resolutionSubjectForMessage)); } - private ChainedTemporaryBindingTrace(TemporaryBindingTrace trace) { - super(trace); + private ChainedTemporaryBindingTrace(TemporaryBindingTrace trace, String debugName) { + super(trace, debugName); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java index 110abc5c45e..404c3441edf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java @@ -36,6 +36,7 @@ public class DelegatingBindingTrace implements BindingTrace { private final BindingContext parentContext; private final MutableSlicedMap map = SlicedMapImpl.create(); private final List diagnostics = Lists.newArrayList(); + private final String name; private final BindingContext bindingContext = new BindingContext() { @Override @@ -67,8 +68,13 @@ public class DelegatingBindingTrace implements BindingTrace { } }; - public DelegatingBindingTrace(BindingContext parentContext) { + public DelegatingBindingTrace(BindingContext parentContext, String debugName) { this.parentContext = parentContext; + this.name = debugName; + } + + public DelegatingBindingTrace(BindingContext parentContext, String debugName, @Nullable Object resolutionSubjectForMessage) { + this(parentContext, AnalyzingUtils.formDebugNameForBindingTrace(debugName, resolutionSubjectForMessage)); } @Override @@ -148,4 +154,9 @@ public class DelegatingBindingTrace implements BindingTrace { public void report(@NotNull Diagnostic diagnostic) { diagnostics.add(diagnostic); } + + @Override + public String toString() { + return name; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 6b9595b0257..b2a004510bd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -111,7 +111,8 @@ public class ImportsResolver { Collection defaultImportDirectives = Lists.newArrayList(); configuration.addDefaultImports(defaultImportDirectives); for (JetImportDirective defaultImportDirective : defaultImportDirectives) { - TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); //not to trace errors of default imports + TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create( + trace, "transient trace to resolve default imports"); //not to trace errors of default imports qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, temporaryTrace, configuration, onlyClasses); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index 7205f6b5b69..bdda76f506d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -112,7 +112,7 @@ public class QualifiedExpressionResolver { if (descriptors.size() == 1) { return canImportMembersFrom(descriptors.iterator().next(), reference, trace, onlyClasses); } - TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); + TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace, "trace to find out if members can be imported from", reference); boolean canImport = false; for (DeclarationDescriptor descriptor : descriptors) { canImport |= canImportMembersFrom(descriptor, reference, temporaryTrace, onlyClasses); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java index 81487406673..1edf93bcbae 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java @@ -17,7 +17,9 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Predicate; +import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.util.slicedmap.WritableSlice; /** @@ -25,14 +27,18 @@ import org.jetbrains.jet.util.slicedmap.WritableSlice; */ public class TemporaryBindingTrace extends DelegatingBindingTrace { - public static TemporaryBindingTrace create(@NotNull BindingTrace trace) { - return new TemporaryBindingTrace(trace); + public static TemporaryBindingTrace create(@NotNull BindingTrace trace, String debugName) { + return new TemporaryBindingTrace(trace, debugName); + } + + public static TemporaryBindingTrace create(@NotNull BindingTrace trace, String debugName, @Nullable Object resolutionSubjectForMessage) { + return create(trace, AnalyzingUtils.formDebugNameForBindingTrace(debugName, resolutionSubjectForMessage)); } protected final BindingTrace trace; - protected TemporaryBindingTrace(@NotNull BindingTrace trace) { - super(trace.getBindingContext()); + protected TemporaryBindingTrace(@NotNull BindingTrace trace, String debugName) { + super(trace.getBindingContext(), debugName); this.trace = trace; } 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 10f731a2000..405e911272e 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 @@ -283,12 +283,13 @@ public class CallResolver { return cachedResults; } } - TemporaryBindingTrace delegatingBindingTrace = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace delegatingBindingTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve call", context.call); BasicResolutionContext newContext = context.replaceTrace(delegatingBindingTrace); OverloadResolutionResults results = doResolveCall(newContext, prioritizedTasks, callTransformer, reference); - DelegatingBindingTrace cloneDelta = new DelegatingBindingTrace(new BindingTraceContext().getBindingContext()); + DelegatingBindingTrace cloneDelta = new DelegatingBindingTrace( + new BindingTraceContext().getBindingContext(), "delta trace for caching resolve of", context.call); delegatingBindingTrace.addAllMyDataTo(cloneDelta); cacheResults(resolutionResultsSlice, context, results, cloneDelta); @@ -465,7 +466,7 @@ public class CallResolver { TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null; OverloadResolutionResultsImpl resultsForFirstNonemptyCandidateSet = null; for (ResolutionTask task : prioritizedTasks) { - TemporaryBindingTrace taskTrace = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace taskTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve a task for", task.reference); OverloadResolutionResultsImpl results = performResolutionGuardedForExtraFunctionLiteralArguments(task.withTrace(taskTrace), callTransformer, context.trace); if (results.isSuccess() || results.isAmbiguity()) { @@ -530,8 +531,9 @@ public class CallResolver { // 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 - ResolutionTask newTask = new ResolutionTask(task.getCandidates(), task.reference, TemporaryBindingTrace.create(task.trace), task.scope, - new DelegatingCall(task.call) { + ResolutionTask newTask = new ResolutionTask(task.getCandidates(), task.reference, + TemporaryBindingTrace.create(task.trace, "trace for resolution guarded for extra function literal arguments"), + task.scope, new DelegatingCall(task.call) { @NotNull @Override public List getFunctionLiteralArguments() { @@ -554,7 +556,8 @@ public class CallResolver { @NotNull BindingTrace traceForResolutionCache) { for (ResolutionCandidate resolutionCandidate : task.getCandidates()) { - TemporaryBindingTrace candidateTrace = TemporaryBindingTrace.create(task.trace); + TemporaryBindingTrace candidateTrace = TemporaryBindingTrace.create( + task.trace, "trace to resolve candidate", resolutionCandidate); Collection> contexts = callTransformer.createCallContexts(resolutionCandidate, task, candidateTrace); for (CallResolutionContext context : contexts) { @@ -799,14 +802,17 @@ public class CallResolver { @NotNull ResolutionContext context) { JetType effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument); - TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create(context.trace); JetExpression argumentExpression = valueArgument.getArgumentExpression(); - JetType type = argumentExpression != null - ? expressionTypingServices.getType( - context.scope, argumentExpression, - substitutor.substitute(effectiveExpectedType, Variance.INVARIANT), - context.dataFlowInfo, traceForUnknown) - : null; + JetType type; + if (argumentExpression != null) { + TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create( + context.trace, "transient trace to resolve argument", argumentExpression); + type = expressionTypingServices.getType(context.scope, argumentExpression, + substitutor.substitute(effectiveExpectedType, Variance.INVARIANT), context.dataFlowInfo, traceForUnknown); + } + else { + type = null; + } constraintSystem.addSupertypeConstraint(effectiveExpectedType, type, ConstraintPosition.getValueParameterPosition( valueParameterDescriptor.getIndex())); //todo no return @@ -1149,7 +1155,7 @@ public class CallResolver { List> candidates = findCandidatesByExactSignature(scope, receiver, name, parameterTypes); BindingTraceContext trace = new BindingTraceContext(); - TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(trace); + TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(trace, "trace for resolve exact signature call", name); Set> calls = Sets.newLinkedHashSet(); for (ResolutionCandidate candidate : candidates) { ResolvedCallImpl call = ResolvedCallImpl.create(candidate, temporaryBindingTrace); 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 ee12572018f..8f90b1f8362 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 @@ -115,7 +115,7 @@ public class CallTransformer { private CallResolutionContext createContextWithChainedTrace(ResolutionCandidate candidate, Call call, TemporaryBindingTrace temporaryTrace, ResolutionTask task) { - ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace); + ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace, "chained trace to resolve candidate", candidate); ResolvedCallImpl resolvedCall = ResolvedCallImpl.create(candidate, chainedTrace); return CallResolutionContext.create(resolvedCall, task, chainedTrace, task.tracing, call); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java index 42f9735cb1b..06412a395f0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java @@ -100,7 +100,8 @@ public class ResolveSessionUtils { @NotNull final ResolveSession resolveSession, @NotNull JetExpression expression ) { - final DelegatingBindingTrace trace = new DelegatingBindingTrace(resolveSession.getBindingContext()); + final DelegatingBindingTrace trace = new DelegatingBindingTrace( + resolveSession.getBindingContext(), "trace to resolve expression", expression); JetFile file = (JetFile) expression.getContainingFile(); @SuppressWarnings("unchecked") @@ -225,7 +226,8 @@ public class ResolveSessionUtils { } public static JetScope getExpressionMemberScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) { - DelegatingBindingTrace trace = new DelegatingBindingTrace(resolveSession.getBindingContext()); + DelegatingBindingTrace trace = new DelegatingBindingTrace( + resolveSession.getBindingContext(), "trace to resolve a member scope of expression", expression); if (expression instanceof JetReferenceExpression) { QualifiedExpressionResolver qualifiedExpressionResolver = resolveSession.getInjector().getQualifiedExpressionResolver(); 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 a1b4d401b2f..db544ad0a30 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 @@ -99,7 +99,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } } JetType[] result = new JetType[1]; - TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create( + context.trace, "trace for namespace/class object lookup of name", referencedName); if (furtherNameLookup(expression, referencedName, result, context.replaceBindingTrace(temporaryTrace))) { temporaryTrace.commit(); return DataFlowUtils.checkType(result[0], expression, context); @@ -201,7 +202,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { boolean tryWithNoExpectedType = true; if (isTypeFlexible(left) || operationType == JetTokens.COLON) { - TemporaryBindingTrace temporaryTraceWithExpectedType = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace temporaryTraceWithExpectedType = TemporaryBindingTrace.create( + context.trace, "trace for resolve RHSExpression", expression); ExpressionTypingContext contextWithTemporaryTrace = context.replaceBindingTrace(temporaryTraceWithExpectedType).replaceExpectedType(targetType); JetTypeInfo typeInfo = facade.getTypeInfo(left, contextWithTemporaryTrace); if (typeInfo.getType() != null && checkBinaryWithTypeRHS(expression, contextWithTemporaryTrace, targetType, typeInfo.getType())) { @@ -633,7 +635,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { private JetType getVariableType(@NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context, @NotNull boolean[] result) { - TemporaryBindingTrace traceForVariable = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace traceForVariable = TemporaryBindingTrace.create( + context.trace, "trace to resolve as local variable or property", nameExpression); OverloadResolutionResults resolutionResult = context.replaceBindingTrace(traceForVariable).resolveSimpleProperty(receiver, callOperationNode, nameExpression); if (!resolutionResult.isNothing()) { traceForVariable.commit(); @@ -645,7 +648,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ExpressionTypingContext newContext = receiver.exists() ? context.replaceScope(receiver.getType().getMemberScope()) : context; - TemporaryBindingTrace traceForNamespaceOrClassObject = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace traceForNamespaceOrClassObject = TemporaryBindingTrace.create( + context.trace, "trace to resolve as namespace or class object", nameExpression); JetType jetType = lookupNamespaceOrClassObject(nameExpression, nameExpression.getReferencedNameAsName(), newContext.replaceBindingTrace(traceForNamespaceOrClassObject)); if (jetType != null) { traceForNamespaceOrClassObject.commit(); @@ -693,7 +697,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { boolean[] result = new boolean[1]; - TemporaryBindingTrace traceForVariable = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace traceForVariable = TemporaryBindingTrace.create(context.trace, "trace to resolve as variable", nameExpression); JetType type = getVariableType(nameExpression, receiver, callOperationNode, context.replaceBindingTrace(traceForVariable), result); if (result[0]) { traceForVariable.commit(); @@ -701,7 +705,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } Call call = CallMaker.makeCall(nameExpression, receiver, callOperationNode, nameExpression, Collections.emptyList()); - TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function", nameExpression); FunctionDescriptor functionDescriptor = getFunctionDescriptor(call, nameExpression, receiver, context, result); if (result[0]) { traceForFunction.commit(); @@ -722,7 +726,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { boolean[] result = new boolean[1]; Call call = CallMaker.makeCall(receiver, callOperationNode, callExpression); - TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function call", callExpression); FunctionDescriptor functionDescriptor = getFunctionDescriptor(call, callExpression, receiver, context.replaceBindingTrace(traceForFunction), result); if (result[0]) { @@ -753,7 +757,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetExpression calleeExpression = callExpression.getCalleeExpression(); if (calleeExpression instanceof JetSimpleNameExpression && callExpression.getTypeArgumentList() == null) { - TemporaryBindingTrace traceForVariable = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace traceForVariable = TemporaryBindingTrace.create( + context.trace, "trace to resolve as variable with 'invoke' call", callExpression); JetType type = getVariableType((JetSimpleNameExpression) calleeExpression, receiver, callOperationNode, context.replaceBindingTrace(traceForVariable), result); if (result[0]) { @@ -828,7 +833,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetExpression stubExpression = ExpressionTypingUtils.createStubExpressionOfNecessaryType(baseExpression.getProject(), type, context.trace); resolveArrayAccessSetMethod((JetArrayAccessExpression) baseExpression, stubExpression, - context.replaceExpectedType(NO_EXPECTED_TYPE).replaceBindingTrace(TemporaryBindingTrace.create(context.trace)), + context.replaceExpectedType(NO_EXPECTED_TYPE).replaceBindingTrace( + TemporaryBindingTrace.create(context.trace, "trace to resolve array access set method for unary expression", expression)), context.trace); } 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 78be4f93f62..7abfb8f41b2 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 @@ -58,7 +58,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { return DataFlowUtils.checkType(type, expression, context, context.dataFlowInfo); } final JetType[] result = new JetType[1]; - final TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace); + final TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve object literal expression", expression); ObservableBindingTrace.RecordHandler handler = new ObservableBindingTrace.RecordHandler() { @Override @@ -83,7 +83,8 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { TopDownAnalyzer.processClassOrObject(context.expressionTypingServices.getProject(), traceAdapter, context.scope, context.scope.getContainingDeclaration(), expression.getObjectDeclaration()); - DelegatingBindingTrace cloneDelta = new DelegatingBindingTrace(new BindingTraceContext().getBindingContext()); + DelegatingBindingTrace cloneDelta = new DelegatingBindingTrace( + new BindingTraceContext().getBindingContext(), "cached delta trace for object literal expression resolve", expression); temporaryTrace.addAllMyDataTo(cloneDelta); context.trace.record(TRACE_DELTAS_CACHE, expression.getObjectDeclaration(), cloneDelta); temporaryTrace.commit(); @@ -112,7 +113,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetType returnType = TypeUtils.NO_EXPECTED_TYPE; JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace); JetTypeReference returnTypeRef = functionLiteral.getReturnTypeRef(); - TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve function literal expression", expression); if (returnTypeRef != null) { returnType = context.expressionTypingServices.getTypeResolver().resolveType(context.scope, returnTypeRef, context.trace, true); context.expressionTypingServices.checkFunctionReturnType(expression, context.replaceScope(functionInnerScope). 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 075ce0d8d99..e8726619286 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 @@ -291,13 +291,13 @@ public class ExpressionTypingServices { if (context.expectedType != NO_EXPECTED_TYPE) { if (coercionStrategyForLastExpression == CoercionStrategy.COERCION_TO_UNIT && KotlinBuiltIns.getInstance().isUnit(context.expectedType)) { // This implements coercion to Unit - TemporaryBindingTrace temporaryTraceExpectingUnit = TemporaryBindingTrace.create(trace); + TemporaryBindingTrace temporaryTraceExpectingUnit = TemporaryBindingTrace.create(trace, "trace to resolve coercion to unit with expected type"); final boolean[] mismatch = new boolean[1]; ObservableBindingTrace errorInterceptingTrace = makeTraceInterceptingTypeMismatch(temporaryTraceExpectingUnit, statementExpression, mismatch); newContext = createContext(newContext, errorInterceptingTrace, scope, newContext.dataFlowInfo, context.expectedType); result = blockLevelVisitor.getTypeInfo(statementExpression, newContext, true); if (mismatch[0]) { - TemporaryBindingTrace temporaryTraceNoExpectedType = TemporaryBindingTrace.create(trace); + TemporaryBindingTrace temporaryTraceNoExpectedType = TemporaryBindingTrace.create(trace, "trace to resolve coercion to unit without expected type"); mismatch[0] = false; ObservableBindingTrace interceptingTrace = makeTraceInterceptingTypeMismatch(temporaryTraceNoExpectedType, statementExpression, mismatch); newContext = createContext(newContext, interceptingTrace, scope, newContext.dataFlowInfo, NO_EXPECTED_TYPE); 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 5a577c497ca..1b58a1f1093 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 @@ -287,7 +287,7 @@ public class ExpressionTypingUtils { @NotNull Name name ) { final JetReferenceExpression fake = JetPsiFactory.createSimpleName(context.expressionTypingServices.getProject(), "fake"); - TemporaryBindingTrace fakeTrace = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace fakeTrace = TemporaryBindingTrace.create(context.trace, "trace for resolve fake call for", name); Call call = CallMaker.makeCall(fake, receiver, null, fake, Collections.emptyList()); OverloadResolutionResults results = context.replaceBindingTrace(fakeTrace).resolveCallWithGivenName(call, fake, name); 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 b2e2952d0cb..0825270d9c7 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 @@ -197,7 +197,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito if (right == null) return null; //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); + 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); JetSimpleNameExpression operationSign = expression.getOperationReference(); @@ -217,13 +218,13 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito // We check that defined only one of '+=' and '+' operations, and call it (in the case '+' we then also assign) // Check for '+=' Name name = OperatorConventions.ASSIGNMENT_OPERATIONS.get(operationType); - TemporaryBindingTrace assignmentOperationTrace = TemporaryBindingTrace.create(context.trace); + TemporaryBindingTrace assignmentOperationTrace = TemporaryBindingTrace.create(context.trace, "trace to check assignment operation like '+=' for", expression); OverloadResolutionResults assignmentOperationDescriptors = basic.getResolutionResultsForBinaryCall(scope, name, context.replaceBindingTrace(assignmentOperationTrace), 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); + TemporaryBindingTrace binaryOperationTrace = TemporaryBindingTrace.create(context.trace, "trace to check binary operation like '+' for", expression); OverloadResolutionResults binaryOperationDescriptors = basic.getResolutionResultsForBinaryCall(scope, counterpartName, context.replaceBindingTrace(binaryOperationTrace), expression, receiver); JetType binaryOperationType = OverloadResolutionResultsUtil.getResultType(binaryOperationDescriptors); @@ -248,7 +249,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito binaryOperationTrace.commit(); context.trace.record(VARIABLE_REASSIGNMENT, expression); if (left instanceof JetArrayAccessExpression) { - ExpressionTypingContext contextForResolve = context.replaceScope(scope).replaceBindingTrace(TemporaryBindingTrace.create(contextWithExpectedType.trace)); + ExpressionTypingContext contextForResolve = context.replaceScope(scope).replaceBindingTrace(TemporaryBindingTrace.create( + contextWithExpectedType.trace, "trace to resolve array set method for assignment", expression)); basic.resolveArrayAccessSetMethod((JetArrayAccessExpression) left, right, contextForResolve, context.trace); } } diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java index fd43c23dc27..bd709706f6e 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java +++ b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java @@ -203,7 +203,7 @@ public class JetPositionManager implements PositionManager { List namespaceFiles = JetFilesProvider.getInstance(file.getProject()).allNamespaceFiles().fun(file); - final DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(analyzeExhaust.getBindingContext()); + final DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(analyzeExhaust.getBindingContext(), "trace created in JetPositionManager"); JetTypeMapper typeMapper = new JetTypeMapper(bindingTrace, true, ClassBuilderMode.FULL); //noinspection unchecked CodegenBinding.initTrace(bindingTrace, namespaceFiles); diff --git a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java index 36fdd62d1e1..5d75133662b 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java @@ -106,7 +106,7 @@ public final class AnalyzerFacadeWithCache { file.getProject(), Collections.emptyList(), new JetFilesProvider.SameJetFilePredicate(file), - new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext()), + new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(), "trace to resolve bodies in file", file.getName()), context, moduleConfiguration); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java index 82b3c09a57d..4eef8707258 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java @@ -101,7 +101,7 @@ public class MigrateTuplesInProjectFix extends JetIntentionAction { initialFile.getProject(), Collections.emptyList(), Predicates.alwaysTrue(), - new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext()), + new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(), "trace in migrate tuples fix"), context, moduleConfiguration); } diff --git a/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java b/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java index d3ba1fa7df7..9d35bb4af85 100644 --- a/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java @@ -51,7 +51,7 @@ public class JetPositionManagerTest extends PositionManagerTestCase { JetPositionManager positionManager = (JetPositionManager) jetPositionManagerFactory.createPositionManager(process); assertNotNull(positionManager); - DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(state.getBindingContext()); + DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(state.getBindingContext(), "trace created in JetPositionManagerTest"); JetTypeMapper typeMapper = new JetTypeMapper(bindingTrace, true, ClassBuilderMode.FULL); //noinspection unchecked CodegenBinding.initTrace(bindingTrace, files); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index 8116f783dbf..eab15f4ed68 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -88,7 +88,7 @@ public final class AnalyzerFacadeForJS { BindingContext libraryBindingContext = config.getLibraryBindingContext(); BindingTrace trace = libraryBindingContext == null ? new ObservableBindingTrace(new BindingTraceContext()) : - new DelegatingBindingTrace(libraryBindingContext); + new DelegatingBindingTrace(libraryBindingContext, "trace for analyzing library in js"); InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( project, topDownAnalysisParameters, trace, owner, new JsConfiguration(project, libraryBindingContext)); diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java index 4cd670eaf15..2b9bafc9359 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java @@ -110,7 +110,7 @@ public final class CallBuilder { resolvedCall = ResolvedCallImpl.create(ResolutionCandidate.create(descriptor, descriptor.getExpectedThisObject(), descriptor.getReceiverParameter(), ExplicitReceiverKind.THIS_OBJECT, false), - TemporaryBindingTrace.create(new BindingTraceContext())); + TemporaryBindingTrace.create(new BindingTraceContext(), "trace to resolve call (in js)")); } if (descriptor == null) { descriptor = resolvedCall.getCandidateDescriptor().getOriginal();