debug names for temporary traces added

compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java

@@ -203,7 +203,7 @@ public final class PsiCodegenPredictor {
     ) {
         final Ref<DeclarationDescriptor> resultingDescriptor = Ref.create();
 
-        DelegatingBindingTrace trace = new DelegatingBindingTrace(context) {
+        DelegatingBindingTrace trace = new DelegatingBindingTrace(context, "trace in PsiCodegenPredictor") {
             @Override
             public <K, V> void record(WritableSlice<K, V> slice, K key, V value) {
                 super.record(slice, key, value);

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);

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;
+    }
 }

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) {
+    public static ChainedTemporaryBindingTrace create(TemporaryBindingTrace trace, String debugName, @Nullable Object resolutionSubjectForMessage) {
-        return new ChainedTemporaryBindingTrace(trace);
+        return new ChainedTemporaryBindingTrace(trace, AnalyzingUtils.formDebugNameForBindingTrace(debugName, resolutionSubjectForMessage));
     }
 
-    private ChainedTemporaryBindingTrace(TemporaryBindingTrace trace) {
+    private ChainedTemporaryBindingTrace(TemporaryBindingTrace trace, String debugName) {
-        super(trace);
+        super(trace, debugName);
     }
 
     @Override

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<Diagnostic> 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;
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java

@@ -111,7 +111,8 @@ public class ImportsResolver {
         Collection<JetImportDirective> 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);
         }

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);

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) {
+    public static TemporaryBindingTrace create(@NotNull BindingTrace trace, String debugName) {
-        return new TemporaryBindingTrace(trace);
+        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) {
+    protected TemporaryBindingTrace(@NotNull BindingTrace trace, String debugName) {
-        super(trace.getBindingContext());
+        super(trace.getBindingContext(), debugName);
         this.trace = trace;
     }
 

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<F> 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<F> resultsForFirstNonemptyCandidateSet = null;
         for (ResolutionTask<D, F> task : prioritizedTasks) {
-            TemporaryBindingTrace taskTrace = TemporaryBindingTrace.create(context.trace);
+            TemporaryBindingTrace taskTrace = TemporaryBindingTrace.create(context.trace, "trace to resolve a task for", task.reference);
             OverloadResolutionResultsImpl<F> 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<D, F> newTask = new ResolutionTask<D, F>(task.getCandidates(), task.reference, TemporaryBindingTrace.create(task.trace), task.scope,
+            ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(task.getCandidates(), task.reference,
-                                                                    new DelegatingCall(task.call) {
+                        TemporaryBindingTrace.create(task.trace, "trace for resolution guarded for extra function literal arguments"),
+                        task.scope, new DelegatingCall(task.call) {
                             @NotNull
                             @Override
                             public List<JetExpression> getFunctionLiteralArguments() {
@@ -554,7 +556,8 @@ public class CallResolver {
             @NotNull BindingTrace traceForResolutionCache) {
 
         for (ResolutionCandidate<D> resolutionCandidate : task.getCandidates()) {
-            TemporaryBindingTrace candidateTrace = TemporaryBindingTrace.create(task.trace);
+            TemporaryBindingTrace candidateTrace = TemporaryBindingTrace.create(
+                    task.trace, "trace to resolve candidate", resolutionCandidate);
             Collection<CallResolutionContext<D, F>> contexts = callTransformer.createCallContexts(resolutionCandidate, task, candidateTrace);
             for (CallResolutionContext<D, F> 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
+        JetType type;
-                       ? expressionTypingServices.getType(
+        if (argumentExpression != null) {
-                            context.scope, argumentExpression,
+            TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create(
-                            substitutor.substitute(effectiveExpectedType, Variance.INVARIANT),
+                    context.trace, "transient trace to resolve argument", argumentExpression);
-                            context.dataFlowInfo, traceForUnknown)
+            type = expressionTypingServices.getType(context.scope, argumentExpression,
-                       : null;
+                    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<ResolutionCandidate<FunctionDescriptor>> 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<ResolvedCallWithTrace<FunctionDescriptor>> calls = Sets.newLinkedHashSet();
         for (ResolutionCandidate<FunctionDescriptor> candidate : candidates) {
             ResolvedCallImpl<FunctionDescriptor> call = ResolvedCallImpl.create(candidate, temporaryBindingTrace);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java

@@ -115,7 +115,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
         private CallResolutionContext<CallableDescriptor, FunctionDescriptor> createContextWithChainedTrace(ResolutionCandidate<CallableDescriptor> candidate,
                 Call call, TemporaryBindingTrace temporaryTrace, ResolutionTask<CallableDescriptor, FunctionDescriptor> task) {
 
-            ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace);
+            ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace, "chained trace to resolve candidate", candidate);
             ResolvedCallImpl<CallableDescriptor> resolvedCall = ResolvedCallImpl.create(candidate, chainedTrace);
             return CallResolutionContext.create(resolvedCall, task, chainedTrace, task.tracing, call);
         }

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();

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<VariableDescriptor> 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.<ValueArgument>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);
         }
 

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<PsiElement, ClassDescriptor> handler = new ObservableBindingTrace.RecordHandler<PsiElement, ClassDescriptor>() {
 
             @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).

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);

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.<ValueArgument>emptyList());
         OverloadResolutionResults<FunctionDescriptor> results =
                 context.replaceBindingTrace(fakeTrace).resolveCallWithGivenName(call, fake, name);

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<FunctionDescriptor> 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<FunctionDescriptor> 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);
             }
         }

idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java

@@ -203,7 +203,7 @@ public class JetPositionManager implements PositionManager {
 
                     List<JetFile> 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);

idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java

@@ -106,7 +106,7 @@ public final class AnalyzerFacadeWithCache {
                                             file.getProject(),
                                             Collections.<AnalyzerScriptParameter>emptyList(),
                                             new JetFilesProvider.SameJetFilePredicate(file),
-                                            new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext()),
+                                            new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(), "trace to resolve bodies in file", file.getName()),
                                             context,
                                             moduleConfiguration);
 

idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java

@@ -101,7 +101,7 @@ public class MigrateTuplesInProjectFix extends JetIntentionAction<PsiElement> {
                 initialFile.getProject(),
                 Collections.<AnalyzerScriptParameter>emptyList(),
                 Predicates.<PsiFile>alwaysTrue(),
-                new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext()),
+                new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext(), "trace in migrate tuples fix"),
                 context,
                 moduleConfiguration);
     }

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);

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));

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();