Clean internal data in resolved call after it's built.

Not to store heavy and unnecessary any longer traces in resolved call.

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

@@ -313,6 +313,10 @@ public class CallResolver {
 
         if (!prioritizedTasks.isEmpty() && context.contextDependency == ContextDependency.INDEPENDENT) {
             results = completeTypeInferenceDependentOnExpectedType(context, results, tracing);
+            if (results.isSingleResult()) {
+                //todo clean internal data for several resulting calls
+                results.getResultingCall().cleanInternalData();
+            }
         }
 
         context.callResolverExtension.run(results, context);

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

@@ -25,16 +25,12 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.*;
 import org.jetbrains.jet.lang.resolve.calls.context.*;
 import org.jetbrains.jet.lang.resolve.calls.inference.*;
-import org.jetbrains.jet.lang.resolve.calls.model.MutableDataFlowInfoForArguments;
+import org.jetbrains.jet.lang.resolve.calls.model.*;
-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.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionDebugInfo;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask;
@@ -373,6 +369,8 @@ public class CandidateResolver {
         }
         JetType result = BindingContextUtils.updateRecordedType(
                 type, expression, context.trace, isFairSafeCallExpression(expression, context.trace));
+
+        contextForArgument.candidateCall.cleanInternalData();
         DataFlowUtils.checkType(result, expression, contextForArgument);
     }
 

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

@@ -81,11 +81,12 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
     private final Set<ValueArgument> unmappedArguments = Sets.newLinkedHashSet();
 
     private boolean someArgumentHasNoType = false;
-    private final DelegatingBindingTrace trace;
+    private DelegatingBindingTrace trace;
-    private final TracingStrategy tracing;
+    private TracingStrategy tracing;
     private ResolutionStatus status = UNKNOWN_STATUS;
     private boolean hasUnknownTypeParameters = false;
     private ConstraintSystem constraintSystem = null;
+    private boolean cleaned = false;
 
     private ResolvedCallImpl(
             @NotNull ResolutionCandidate<D> candidate,
@@ -130,11 +131,25 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
     @Override
     @NotNull
     public DelegatingBindingTrace getTrace() {
+        checkCallIsUnfinished("Trace");
         return trace;
     }
 
+    @Override
+    public void cleanInternalData() {
+        trace = null;
+        constraintSystem = null;
+        tracing = null;
+        cleaned = true;
+    }
+
+    private void checkCallIsUnfinished(String elementName) {
+        if (cleaned) throw new IllegalStateException(elementName + " is erased after resolution completion.");
+    }
+
     @NotNull
     public TracingStrategy getTracing() {
+        checkCallIsUnfinished("TracingStrategy");
         return tracing;
     }
 
@@ -181,6 +196,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
 
     @Nullable
     public ConstraintSystem getConstraintSystem() {
+        checkCallIsUnfinished("ConstraintSystem");
         return constraintSystem;
     }
 

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

@@ -45,4 +45,6 @@ public interface ResolvedCallWithTrace<D extends CallableDescriptor> extends Res
      */
     @NotNull
     ResolvedCallImpl<D> getCallToCompleteTypeArgumentInference();
+
+    void cleanInternalData();
 }

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

@@ -137,4 +137,10 @@ public class VariableAsFunctionResolvedCall implements ResolvedCallWithTrace<Fun
     public DataFlowInfoForArguments getDataFlowInfoForArguments() {
         return functionCall.getDataFlowInfoForArguments();
     }
+
+    @Override
+    public void cleanInternalData() {
+        functionCall.cleanInternalData();
+        variableCall.cleanInternalData();
+    }
 }