Added collectAllCandidates flag to ResolutionContext

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

@@ -172,7 +172,8 @@ public class AnnotationResolver {
                 CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, annotationEntry),
                 NO_EXPECTED_TYPE,
                 DataFlowInfo.EMPTY,
-                true);
+                true
+        );
     }
 
     public void resolveAnnotationsArguments(@NotNull JetScope scope, @Nullable JetModifierList modifierList, @NotNull BindingTrace trace) {

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

@@ -24,11 +24,9 @@ import com.intellij.util.containers.Queue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.evaluate.EvaluatePackage;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.context.ContextDependency;
-import org.jetbrains.jet.lang.resolve.calls.context.ResolutionResultsCacheImpl;
 import org.jetbrains.jet.lang.resolve.calls.context.SimpleResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
@@ -38,7 +36,6 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.expressions.DataFlowUtils;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
-import org.jetbrains.jet.lang.types.expressions.LabelResolver;
 import org.jetbrains.jet.lexer.JetKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.util.Box;
@@ -203,8 +200,7 @@ public class BodyResolver {
                     if (type != null && supertype != null) {
                         SimpleResolutionContext simpleResolutionContext = new SimpleResolutionContext(
                                 trace, scope, supertype, c.getOuterDataFlowInfo(), ContextDependency.INDEPENDENT,
-                                ResolutionResultsCacheImpl.create(), LabelResolver.create(),
+                                expressionTypingServices.createExtension(scope, false));
-                                expressionTypingServices.createExtension(scope, false), false);
                         DataFlowUtils.checkType(type, delegateExpression, simpleResolutionContext);
                     }
                 }

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

@@ -182,10 +182,11 @@ public class CallResolver {
             @NotNull DataFlowInfo dataFlowInfo,
             boolean isAnnotationContext
     ) {
-        return resolveFunctionCall(BasicCallResolutionContext.create(
+        return resolveFunctionCall(
-                trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
+                BasicCallResolutionContext.create(
-                ResolutionResultsCacheImpl.create(), LabelResolver.create(), null,
+                        trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
-                expressionTypingServices.createExtension(scope, isAnnotationContext), isAnnotationContext));
+                        expressionTypingServices.createExtension(scope, isAnnotationContext), isAnnotationContext)
+        );
     }
 
     @NotNull

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

@@ -28,8 +28,7 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.LabelResolver;
 
 public class BasicCallResolutionContext extends CallResolutionContext<BasicCallResolutionContext> {
-    @NotNull
+    private BasicCallResolutionContext(
-    public static BasicCallResolutionContext create(
             @NotNull BindingTrace trace,
             @NotNull JetScope scope,
             @NotNull Call call,
@@ -41,11 +40,28 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull LabelResolver labelResolver,
             @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
             @NotNull CallResolverExtension callResolverExtension,
+            boolean isAnnotationContext,
+            boolean collectAllCandidates
+    ) {
+        super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache, labelResolver,
+              dataFlowInfoForArguments, callResolverExtension, isAnnotationContext, collectAllCandidates);
+    }
+
+    @NotNull
+    public static BasicCallResolutionContext create(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull Call call,
+            @NotNull JetType expectedType,
+            @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull ContextDependency contextDependency,
+            @NotNull CheckValueArgumentsMode checkArguments,
+            @NotNull CallResolverExtension callResolverExtension,
             boolean isAnnotationContext
     ) {
-        return new BasicCallResolutionContext(
+        return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
-                trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache, labelResolver,
+             ResolutionResultsCacheImpl.create(), LabelResolver.create(), null,
-                dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
+             callResolverExtension, isAnnotationContext, false);
     }
 
     @NotNull
@@ -53,10 +69,9 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull ResolutionContext context, @NotNull Call call, @NotNull CheckValueArgumentsMode checkArguments,
             @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments
     ) {
-        return create(
+        return new BasicCallResolutionContext(context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, context.contextDependency, checkArguments,
-                context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, context.contextDependency, checkArguments,
+             context.resolutionResultsCache, context.labelResolver, dataFlowInfoForArguments, context.callResolverExtension,
-                context.resolutionResultsCache, context.labelResolver, dataFlowInfoForArguments, context.callResolverExtension,
+             context.isAnnotationContext, context.collectAllCandidates);
-                context.isAnnotationContext);
     }
 
     @NotNull
@@ -66,17 +81,6 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
         return create(context, call, checkArguments, null);
     }
 
-    private BasicCallResolutionContext(
-            BindingTrace trace, JetScope scope, Call call, JetType expectedType,
-            DataFlowInfo dataFlowInfo, ContextDependency contextDependency, CheckValueArgumentsMode checkArguments,
-            ResolutionResultsCache resolutionResultsCache, LabelResolver labelResolver,
-            MutableDataFlowInfoForArguments dataFlowInfoForArguments, CallResolverExtension callResolverExtension,
-            boolean isAnnotationContext
-    ) {
-        super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache, labelResolver,
-              dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
-    }
-
     @Override
     protected BasicCallResolutionContext create(
             @NotNull BindingTrace trace,
@@ -85,14 +89,17 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull JetType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull LabelResolver labelResolver
+            @NotNull LabelResolver labelResolver,
+            boolean collectAllCandidates
     ) {
-        return create(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
+        return new BasicCallResolutionContext(
-                      labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
+                trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
+                labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext, collectAllCandidates);
     }
 
     public BasicCallResolutionContext replaceCall(@NotNull Call newCall) {
-        return create(trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
+        return new BasicCallResolutionContext(
-                      labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
+                trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
+                labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext, collectAllCandidates);
     }
 }

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

@@ -51,10 +51,11 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
             @NotNull CallResolverExtension callResolverExtension,
             @NotNull ReceiverValue explicitExtensionReceiverForInvoke,
-            boolean isAnnotationContext
+            boolean isAnnotationContext,
+            boolean collectAllCandidates
     ) {
         super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache, labelResolver,
-              dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
+              dataFlowInfoForArguments, callResolverExtension, isAnnotationContext, collectAllCandidates);
         this.candidateCall = candidateCall;
         this.tracing = tracing;
         this.explicitExtensionReceiverForInvoke = explicitExtensionReceiverForInvoke;
@@ -69,7 +70,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
                 candidateCall, tracing, trace, context.scope, call, context.expectedType,
                 context.dataFlowInfo, context.contextDependency, context.checkArguments,
                 context.resolutionResultsCache, context.labelResolver, context.dataFlowInfoForArguments,
-                context.callResolverExtension, explicitExtensionReceiverForInvoke, context.isAnnotationContext);
+                context.callResolverExtension, explicitExtensionReceiverForInvoke, context.isAnnotationContext, context.collectAllCandidates);
     }
 
     public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> create(
@@ -92,7 +93,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
                 candidateCall, tracing, context.trace, context.scope, context.call, context.expectedType,
                 context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache,
                 context.labelResolver, context.dataFlowInfoForArguments, context.callResolverExtension, ReceiverValue.NO_RECEIVER,
-                context.isAnnotationContext);
+                context.isAnnotationContext, context.collectAllCandidates);
     }
 
     @Override
@@ -103,11 +104,12 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull JetType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull LabelResolver labelResolver
+            @NotNull LabelResolver labelResolver,
+            boolean collectAllCandidates
     ) {
         return new CallCandidateResolutionContext<D>(
                 candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
                 resolutionResultsCache, labelResolver, dataFlowInfoForArguments, callResolverExtension, explicitExtensionReceiverForInvoke,
-                isAnnotationContext);
+                isAnnotationContext, collectAllCandidates);
     }
 }

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

@@ -47,10 +47,11 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
             @SuppressWarnings("NullableProblems")
             @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
             @NotNull CallResolverExtension callResolverExtension,
-            boolean isAnnotationContext
+            boolean isAnnotationContext,
+            boolean collectAllCandidates
     ) {
         super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, labelResolver, callResolverExtension,
-              isAnnotationContext);
+              isAnnotationContext, collectAllCandidates);
         this.call = call;
         this.checkArguments = checkArguments;
         if (dataFlowInfoForArguments != null) {

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

@@ -36,6 +36,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
     public final LabelResolver labelResolver;
     public final CallResolverExtension callResolverExtension;
     public final boolean isAnnotationContext;
+    public final boolean collectAllCandidates;
 
     protected ResolutionContext(
             @NotNull BindingTrace trace,
@@ -46,7 +47,8 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull LabelResolver labelResolver,
             @NotNull CallResolverExtension callResolverExtension,
-            boolean isAnnotationContext
+            boolean isAnnotationContext,
+            boolean collectAllCandidates
     ) {
         this.trace = trace;
         this.scope = scope;
@@ -57,6 +59,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
         this.labelResolver = labelResolver;
         this.callResolverExtension = callResolverExtension;
         this.isAnnotationContext = isAnnotationContext;
+        this.collectAllCandidates = collectAllCandidates;
     }
 
     protected abstract Context create(
@@ -66,7 +69,8 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
             @NotNull JetType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull LabelResolver labelResolver
+            @NotNull LabelResolver labelResolver,
+            boolean collectAllCandidates
     );
 
     @NotNull
@@ -78,42 +82,47 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
     @NotNull
     public Context replaceBindingTrace(@NotNull BindingTrace trace) {
         if (this.trace == trace) return self();
-        return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, labelResolver);
+        return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, labelResolver, collectAllCandidates);
     }
 
     @NotNull
     public Context replaceDataFlowInfo(@NotNull DataFlowInfo newDataFlowInfo) {
         if (newDataFlowInfo == dataFlowInfo) return self();
-        return create(trace, scope, newDataFlowInfo, expectedType, contextDependency, resolutionResultsCache, labelResolver);
+        return create(trace, scope, newDataFlowInfo, expectedType, contextDependency, resolutionResultsCache, labelResolver, collectAllCandidates);
     }
 
     @NotNull
     public Context replaceExpectedType(@Nullable JetType newExpectedType) {
         if (newExpectedType == null) return replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE);
         if (expectedType == newExpectedType) return self();
-        return create(trace, scope, dataFlowInfo, newExpectedType, contextDependency, resolutionResultsCache, labelResolver);
+        return create(trace, scope, dataFlowInfo, newExpectedType, contextDependency, resolutionResultsCache, labelResolver, collectAllCandidates);
     }
 
     @NotNull
     public Context replaceScope(@NotNull JetScope newScope) {
         if (newScope == scope) return self();
-        return create(trace, newScope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, labelResolver);
+        return create(trace, newScope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, labelResolver, collectAllCandidates);
     }
 
     @NotNull
     public Context replaceContextDependency(@NotNull ContextDependency newContextDependency) {
         if (newContextDependency == contextDependency) return self();
-        return create(trace, scope, dataFlowInfo, expectedType, newContextDependency, resolutionResultsCache, labelResolver);
+        return create(trace, scope, dataFlowInfo, expectedType, newContextDependency, resolutionResultsCache, labelResolver, collectAllCandidates);
     }
 
     @NotNull
     public Context replaceResolutionResultsCache(@NotNull ResolutionResultsCache newResolutionResultsCache) {
         if (newResolutionResultsCache == resolutionResultsCache) return self();
-        return create(trace, scope, dataFlowInfo, expectedType, contextDependency, newResolutionResultsCache, labelResolver);
+        return create(trace, scope, dataFlowInfo, expectedType, contextDependency, newResolutionResultsCache, labelResolver, collectAllCandidates);
     }
 
     @NotNull
     public Context replaceTraceAndCache(@NotNull TemporaryTraceAndCache traceAndCache) {
         return replaceBindingTrace(traceAndCache.trace).replaceResolutionResultsCache(traceAndCache.cache);
     }
+
+    @NotNull
+    public Context replaceCollectAllCandidates(boolean newCollectAllCandidates) {
+        return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, labelResolver, newCollectAllCandidates);
+    }
 }

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

@@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.LabelResolver;
 
 public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionContext> {
-    public SimpleResolutionContext(
+    private SimpleResolutionContext(
             @NotNull BindingTrace trace,
             @NotNull JetScope scope,
             @NotNull JetType expectedType,
@@ -34,10 +34,23 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull LabelResolver labelResolver,
             @NotNull CallResolverExtension callResolverExtension,
-            boolean isAnnotationContext
+            boolean isAnnotationContext,
+            boolean collectAllCandidates
     ) {
         super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, labelResolver, callResolverExtension,
-              isAnnotationContext);
+              isAnnotationContext, collectAllCandidates);
+    }
+
+    public SimpleResolutionContext(
+            @NotNull BindingTrace trace,
+            @NotNull JetScope scope,
+            @NotNull JetType expectedType,
+            @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull ContextDependency contextDependency,
+            @NotNull CallResolverExtension callResolverExtension
+    ) {
+        this(trace, scope, expectedType, dataFlowInfo, contextDependency, ResolutionResultsCacheImpl.create(),
+             LabelResolver.create(), callResolverExtension, false, false);
     }
 
     @Override
@@ -48,10 +61,11 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
             @NotNull JetType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull LabelResolver labelResolver
+            @NotNull LabelResolver labelResolver,
+            boolean collectAllCandidates
     ) {
         return new SimpleResolutionContext(
                 trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, labelResolver, callResolverExtension,
-                isAnnotationContext);
+                isAnnotationContext, collectAllCandidates);
     }
 }

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

@@ -44,16 +44,25 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
     private DescriptorCheckStrategy checkingStrategy;
     public final TracingStrategy tracing;
 
-    public ResolutionTask(
+    private ResolutionTask(
             @NotNull Collection<ResolutionCandidate<D>> candidates,
-            @NotNull TracingStrategy tracing, BindingTrace trace, JetScope scope, Call call, JetType expectedType,
+            @NotNull TracingStrategy tracing,
-            DataFlowInfo dataFlowInfo, ContextDependency contextDependency, CheckValueArgumentsMode checkArguments,
+            @NotNull BindingTrace trace,
-            ResolutionResultsCache resolutionResultsCache, @NotNull LabelResolver labelResolver,
+            @NotNull JetScope scope,
-            @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments, @NotNull CallResolverExtension callResolverExtension,
+            @NotNull Call call,
-            boolean isAnnotationContext
+            @NotNull JetType expectedType,
+            @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull ContextDependency contextDependency,
+            @NotNull CheckValueArgumentsMode checkArguments,
+            @NotNull ResolutionResultsCache resolutionResultsCache,
+            @NotNull LabelResolver labelResolver,
+            @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
+            @NotNull CallResolverExtension callResolverExtension,
+            boolean isAnnotationContext,
+            boolean collectAllCandidates
     ) {
         super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
-              labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
+              labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext, collectAllCandidates);
         this.candidates = candidates;
         this.tracing = tracing;
     }
@@ -67,7 +76,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
              context.trace, context.scope, context.call,
              context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments,
              context.resolutionResultsCache, context.labelResolver, context.dataFlowInfoForArguments,
-             context.callResolverExtension, context.isAnnotationContext);
+             context.callResolverExtension, context.isAnnotationContext, context.collectAllCandidates);
     }
 
     public ResolutionTask(
@@ -107,11 +116,13 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
             @NotNull JetType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull LabelResolver labelResolver
+            @NotNull LabelResolver labelResolver,
+            boolean collectAllCandidates
     ) {
         ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(
                 candidates, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
-                resolutionResultsCache, labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
+                resolutionResultsCache, labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext,
+                collectAllCandidates);
         newTask.setCheckingStrategy(checkingStrategy);
         return newTask;
     }
@@ -119,7 +130,8 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
     public ResolutionTask<D, F> replaceCall(@NotNull Call newCall) {
         return new ResolutionTask<D, F>(
                 candidates, tracing, trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments,
-                resolutionResultsCache, labelResolver, dataFlowInfoForArguments, callResolverExtension, isAnnotationContext);
+                resolutionResultsCache, labelResolver, dataFlowInfoForArguments, callResolverExtension,
+                isAnnotationContext, collectAllCandidates);
     }
 
     public interface DescriptorCheckStrategy {

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java

@@ -45,11 +45,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
     }
 
     @NotNull
-    public static ExpressionTypingContext newContext(@NotNull ResolutionContext resolutionContext) {
+    public static ExpressionTypingContext newContext(@NotNull ResolutionContext context) {
-        return newContext(resolutionContext.trace, resolutionContext.scope, resolutionContext.dataFlowInfo,
+        return new ExpressionTypingContext(
-                          resolutionContext.expectedType, resolutionContext.contextDependency,
+                context.labelResolver, context.trace, context.scope, context.scope.getContainingDeclaration(),
-                          resolutionContext.resolutionResultsCache, resolutionContext.labelResolver,
+                context.dataFlowInfo, context.expectedType, context.contextDependency, context.resolutionResultsCache,
-                          resolutionContext.callResolverExtension, resolutionContext.isAnnotationContext);
+                context.callResolverExtension, context.isAnnotationContext, context.collectAllCandidates
+        );
     }
 
     @NotNull
@@ -64,8 +65,9 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull CallResolverExtension callResolverExtension,
             boolean isAnnotationContext
     ) {
-        return new ExpressionTypingContext(labelResolver, trace, scope, scope.getContainingDeclaration(), dataFlowInfo,
+        return new ExpressionTypingContext(
-                                           expectedType, contextDependency, resolutionResultsCache, callResolverExtension, isAnnotationContext);
+                labelResolver, trace, scope, scope.getContainingDeclaration(), dataFlowInfo, expectedType, contextDependency,
+                resolutionResultsCache, callResolverExtension, isAnnotationContext, false);
     }
 
     public final DeclarationDescriptor containingDeclaration;
@@ -81,10 +83,11 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull CallResolverExtension callResolverExtension,
-            boolean isAnnotationContext
+            boolean isAnnotationContext,
+            boolean collectAllCandidates
     ) {
         super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, labelResolver, callResolverExtension,
-              isAnnotationContext);
+              isAnnotationContext, collectAllCandidates);
         this.containingDeclaration = containingDeclaration;
     }
 
@@ -96,11 +99,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull JetType expectedType,
             @NotNull ContextDependency contextDependency,
             @NotNull ResolutionResultsCache resolutionResultsCache,
-            @NotNull LabelResolver labelResolver
+            @NotNull LabelResolver labelResolver,
+            boolean collectAllCandidates
     ) {
         return new ExpressionTypingContext(this.labelResolver, trace, scope, containingDeclaration, dataFlowInfo,
                                            expectedType, contextDependency, resolutionResultsCache, callResolverExtension,
-                                           isAnnotationContext);
+                                           isAnnotationContext, collectAllCandidates);
     }
 
 ///////////// LAZY ACCESSORS

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java

@@ -346,9 +346,9 @@ public class ExpressionTypingServices {
     }
 
     private ExpressionTypingContext createContext(ExpressionTypingContext oldContext, BindingTrace trace, WritableScope scope, DataFlowInfo dataFlowInfo, JetType expectedType) {
-        return ExpressionTypingContext.newContext(trace, scope, dataFlowInfo, expectedType, oldContext.contextDependency,
+        return ExpressionTypingContext.newContext(
-                                                  oldContext.resolutionResultsCache, oldContext.labelResolver,
+                trace, scope, dataFlowInfo, expectedType, oldContext.contextDependency, oldContext.resolutionResultsCache,
-                                                  oldContext.callResolverExtension, oldContext.isAnnotationContext);
+                oldContext.labelResolver, oldContext.callResolverExtension, oldContext.isAnnotationContext);
     }
 
     @Nullable