added ability to resolve call with uncustomary tracing strategy

(necessary for special 'tracing for if')

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

@@ -206,7 +206,7 @@ public class CallResolver {
                     }
                     Collection<ResolutionCandidate<CallableDescriptor>> candidates = TaskPrioritizer.<CallableDescriptor>convertWithImpliedThis(context.scope, Collections.<ReceiverValue>singletonList(NO_RECEIVER), constructors);
                     prioritizedTasks = TaskPrioritizer.<CallableDescriptor, FunctionDescriptor>computePrioritizedTasksFromCandidates(
-                            context, functionReference, candidates);
+                            context, functionReference, candidates, null);
                 }
                 else {
                     context.trace.report(NOT_A_CLASS.on(calleeExpression));

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

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.calls.tasks;
 
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.psi.Call;
 import org.jetbrains.jet.lang.psi.JetReferenceExpression;
@@ -53,12 +54,26 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
         this.tracing = tracing;
     }
 
-    public ResolutionTask(@NotNull Collection<ResolutionCandidate<D>> candidates, @NotNull JetReferenceExpression reference, @NotNull BasicCallResolutionContext context) {
+    public ResolutionTask(
-        this(candidates, reference, TracingStrategyImpl.create(reference, context.call), context.trace, context.scope, context.call,
+            @NotNull Collection<ResolutionCandidate<D>> candidates,
+            @NotNull JetReferenceExpression reference,
+            @NotNull BasicCallResolutionContext context,
+            @Nullable TracingStrategy tracing
+    ) {
+        this(candidates, reference, tracing != null ? tracing : TracingStrategyImpl.create(reference, context.call),
+             context.trace, context.scope, context.call,
              context.expectedType, context.dataFlowInfo, context.resolveMode, context.checkArguments,
              context.expressionPosition, context.resolutionResultsCache);
     }
 
+    public ResolutionTask(
+            @NotNull Collection<ResolutionCandidate<D>> candidates,
+            @NotNull JetReferenceExpression reference,
+            @NotNull BasicCallResolutionContext context
+    ) {
+        this(candidates, reference, context, null);
+    }
+
     @NotNull
     public Collection<ResolutionCandidate<D>> getCandidates() {
         return candidates;

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

@@ -34,6 +34,7 @@ public class ResolutionTaskHolder<D extends CallableDescriptor, F extends D> {
     private final JetReferenceExpression reference;
     private final BasicCallResolutionContext basicCallResolutionContext;
     private final PriorityProvider<ResolutionCandidate<D>> priorityProvider;
+    private final TracingStrategy tracing;
     private final boolean isSafeCall;
 
     private final Collection<Collection<ResolutionCandidate<D>>> candidatesList = Lists.newArrayList();
@@ -42,11 +43,13 @@ public class ResolutionTaskHolder<D extends CallableDescriptor, F extends D> {
 
     public ResolutionTaskHolder(@NotNull JetReferenceExpression reference,
             @NotNull BasicCallResolutionContext basicCallResolutionContext,
-            @NotNull PriorityProvider<ResolutionCandidate<D>> priorityProvider
+            @NotNull PriorityProvider<ResolutionCandidate<D>> priorityProvider,
+            @Nullable TracingStrategy tracing
     ) {
         this.reference = reference;
         this.basicCallResolutionContext = basicCallResolutionContext;
         this.priorityProvider = priorityProvider;
+        this.tracing = tracing;
         this.isSafeCall = JetPsiUtil.isSafeCall(basicCallResolutionContext.call);
     }
 
@@ -83,7 +86,7 @@ public class ResolutionTaskHolder<D extends CallableDescriptor, F extends D> {
                         }
                     });
                     if (!filteredCandidates.isEmpty()) {
-                        tasks.add(new ResolutionTask<D, F>(filteredCandidates, reference, basicCallResolutionContext));
+                        tasks.add(new ResolutionTask<D, F>(filteredCandidates, reference, basicCallResolutionContext, tracing));
                     }
                 }
             }

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

@@ -92,7 +92,7 @@ public class TaskPrioritizer {
             scope = context.scope;
         }
 
-        ResolutionTaskHolder<D, F> result = new ResolutionTaskHolder<D, F>(functionReference, context, new MyPriorityProvider<D>(context));
+        ResolutionTaskHolder<D, F> result = new ResolutionTaskHolder<D, F>(functionReference, context, new MyPriorityProvider<D>(context), null);
         TaskPrioritizerContext<D, F> c = new TaskPrioritizerContext<D, F>(name, result, context, scope, callableDescriptorCollectors);
         doComputeTasks(explicitReceiver, c);
         return result.getTasks();
@@ -337,9 +337,11 @@ public class TaskPrioritizer {
     public static <D extends CallableDescriptor, F extends D> List<ResolutionTask<D, F>> computePrioritizedTasksFromCandidates(
             @NotNull BasicCallResolutionContext context,
             @NotNull JetReferenceExpression functionReference,
-            @NotNull Collection<ResolutionCandidate<D>> candidates
+            @NotNull Collection<ResolutionCandidate<D>> candidates,
+            @Nullable TracingStrategy tracing
     ) {
-        ResolutionTaskHolder<D, F> result = new ResolutionTaskHolder<D, F>(functionReference, context, new MyPriorityProvider<D>(context));
+        ResolutionTaskHolder<D, F> result = new ResolutionTaskHolder<D, F>(
+                functionReference, context, new MyPriorityProvider<D>(context), tracing);
         result.addCandidates(candidates);
         return result.getTasks();
     }