resolvedCalls set instead of multiMap stored in ResolutionTask

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.lang.resolve.calls;
 
-import com.google.common.collect.LinkedHashMultimap;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
 import com.intellij.lang.ASTNode;
@@ -39,6 +38,7 @@ import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collection;
 import java.util.List;
+import java.util.Set;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.*;
@@ -48,9 +48,9 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.*;
  *
  * @author abreslav
  */
-public class ResolutionTask<D extends CallableDescriptor> extends ResolutionContext {
+public class ResolutionTask<D extends CallableDescriptor, F extends D> extends ResolutionContext {
     private final Collection<ResolutionCandidate<D>> candidates;
-    private final Multimap<ResolutionCandidate<D>, ResolvedCallImpl<D>> resolvedCallMap = LinkedHashMultimap.create();
+    private final Set<ResolvedCallWithTrace<F>> resolvedCalls = Sets.newLinkedHashSet();
     /*package*/ final JetReferenceExpression reference;
     private DescriptorCheckStrategy checkingStrategy;
 
@@ -71,8 +71,8 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
     }
 
     @NotNull
-    public Multimap<ResolutionCandidate<D>, ResolvedCallImpl<D>> getResolvedCallMap() {
-        return resolvedCallMap;
+    public Set<ResolvedCallWithTrace<F>> getResolvedCalls() {
+        return resolvedCalls;
     }
 
     public void setCheckingStrategy(DescriptorCheckStrategy strategy) {
@@ -86,8 +86,8 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
         return true;
     }
 
-    public ResolutionTask<D> withTrace(BindingTrace newTrace) {
-        ResolutionTask<D> newTask = new ResolutionTask<D>(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo);
+    public ResolutionTask<D, F> withTrace(BindingTrace newTrace) {
+        ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo);
         newTask.setCheckingStrategy(checkingStrategy);
         return newTask;
     }
@@ -98,22 +98,15 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
 
     public final TracingStrategy tracing = new TracingStrategy() {
         @Override
-        public <D extends CallableDescriptor> void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl<D> resolvedCall) {
-            D descriptor = resolvedCall.getCandidateDescriptor();
-            //                if (descriptor instanceof VariableAsFunctionDescriptor) {
-            //                    VariableAsFunctionDescriptor variableAsFunctionDescriptor = (VariableAsFunctionDescriptor) descriptor;
-            //                    trace.record(REFERENCE_TARGET, reference, variableAsFunctionDescriptor.getVariableDescriptor());
-            //                }
-            //                else {
-            //                }
+        public <D extends CallableDescriptor> void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace<D> resolvedCall) {
+            trace.record(REFERENCE_TARGET, reference, resolvedCall.getResultingDescriptor());
             trace.record(RESOLVED_CALL, call.getCalleeExpression(), resolvedCall);
-            trace.record(REFERENCE_TARGET, reference, descriptor);
         }
 
         @Override
-        public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallImpl<D>> candidates) {
+        public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallWithTrace<D>> candidates) {
             Collection<D> descriptors = Sets.newHashSet();
-            for (ResolvedCallImpl<D> candidate : candidates) {
+            for (ResolvedCallWithTrace<D> candidate : candidates) {
                 descriptors.add(candidate.getCandidateDescriptor());
             }
             trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, descriptors);
@@ -155,7 +148,14 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
 
         @Override
         public void noReceiverAllowed(@NotNull BindingTrace trace) {
-            trace.report(NO_RECEIVER_ADMITTED.on(reference));
+            if (reference instanceof JetSimpleNameExpression) {
+                //todo temporary hack
+                //should be stored that the reference is unresolved (and not trace the candidate descriptor)
+                trace.report(UNRESOLVED_REFERENCE.on(reference));
+            }
+            else {
+                trace.report(NO_RECEIVER_ADMITTED.on(reference));
+            }
         }
 
         @Override
@@ -170,12 +170,12 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
         }
 
         @Override
-        public <D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors) {
+        public <D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors) {
             trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallElement(), descriptors));
         }
 
         @Override
-        public <D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors) {
+        public <D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors) {
             trace.report(NONE_APPLICABLE.on(reference, descriptors));
         }
 
@@ -233,8 +233,7 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
 
         @Override
         public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor) {
-            JetExpression expression = call.getCalleeExpression();
-            trace.report(INVISIBLE_MEMBER.on(expression != null ? expression : call.getCallElement(), descriptor, descriptor.getContainingDeclaration()));
+            trace.report(INVISIBLE_MEMBER.on(call.getCallElement(), descriptor, descriptor.getContainingDeclaration()));
         }
     };
 }

idea/src/org/jetbrains/jet/plugin/internal/resolvewindow/ResolveToolwindow.java

@@ -192,9 +192,9 @@ public class ResolveToolwindow extends JPanel implements Disposable {
         StringBuilder result = new StringBuilder();
         
         if (debugInfo != null) {
-            List<? extends ResolutionTask<? extends CallableDescriptor>> resolutionTasks = debugInfo.get(TASKS);
-            for (ResolutionTask<? extends CallableDescriptor> resolutionTask : resolutionTasks) {
-                for (ResolvedCallImpl<? extends CallableDescriptor> resolvedCall : resolutionTask.getResolvedCallMap().values()) {
+            List<? extends ResolutionTask<? extends CallableDescriptor, ?>> resolutionTasks = debugInfo.get(TASKS);
+            for (ResolutionTask<? extends CallableDescriptor, ?> resolutionTask : resolutionTasks) {
+                for (ResolvedCallWithTrace<? extends CallableDescriptor> resolvedCall : resolutionTask.getResolvedCalls()) {
                     renderResolutionLogForCall(debugInfo, resolvedCall, result);
                 }
             }
@@ -212,7 +212,7 @@ public class ResolveToolwindow extends JPanel implements Disposable {
         return result.toString();
     }
 
-    private void renderResolutionLogForCall(Data debugInfo, ResolvedCallImpl<? extends CallableDescriptor> resolvedCall, StringBuilder result) {
+    private void renderResolutionLogForCall(Data debugInfo, ResolvedCallWithTrace<? extends CallableDescriptor> resolvedCall, StringBuilder result) {
         result.append("Trying to call ").append(resolvedCall.getCandidateDescriptor()).append("\n");
         StringBuilder errors = debugInfo.getByKey(ERRORS, resolvedCall);
         if (errors != null) {