moved ResolveMode, ResolutionResultsCache

from CallResolutionContext to ResolutionContext

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

@@ -27,7 +27,9 @@ import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorUtil;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
 import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition;
+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.inference.ConstraintPosition;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
@@ -213,9 +215,10 @@ public class BodyResolver {
                                      : scopeForConstructor;
                     JetType type = typeInferrer.getType(scope, delegateExpression, NO_EXPECTED_TYPE, context.getOuterDataFlowInfo(), trace);
                     if (type != null && supertype != null) {
-                        DataFlowUtils.checkType(type, delegateExpression,
+                        SimpleResolutionContext simpleResolutionContext = new SimpleResolutionContext(
-                                                new SimpleResolutionContext(trace, scope, supertype, context.getOuterDataFlowInfo(),
+                                trace, scope, supertype, context.getOuterDataFlowInfo(), ExpressionPosition.FREE, ResolveMode.NORMAL,
-                                                                      ExpressionPosition.FREE));
+                                ResolutionResultsCacheImpl.create());
+                        DataFlowUtils.checkType(type, delegateExpression, simpleResolutionContext);
                     }
                 }
             }

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

@@ -184,17 +184,16 @@ public class CallExpressionResolver {
     @Nullable
     public ResolvedCallWithTrace<FunctionDescriptor> getResolvedCallForFunction(
             @NotNull Call call, @NotNull JetExpression callExpression,
-            @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionContext context, @NotNull CheckValueArgumentsMode checkArguments,
-            @NotNull CheckValueArgumentsMode checkArguments, @NotNull ResolutionResultsCache resolutionResultsCache,
             @NotNull boolean[] result
     ) {
         CallResolver callResolver = expressionTypingServices.getCallResolver();
         OverloadResolutionResultsImpl<FunctionDescriptor> results = callResolver.resolveFunctionCall(
-                BasicCallResolutionContext.create(context, call, resolveMode, checkArguments, resolutionResultsCache));
+                BasicCallResolutionContext.create(context, call, checkArguments));
         if (!results.isNothing()) {
             checkSuper(call.getExplicitReceiver(), results, context.trace, callExpression);
             result[0] = true;
-            if (results.isSingleResult() && resolveMode == ResolveMode.TOP_LEVEL_CALL) {
+            if (results.isSingleResult() && context.resolveMode == ResolveMode.TOP_LEVEL_CALL) {
                 if (!CallResolverUtil.hasInferredReturnType(results.getResultingCall())) return null;
             }
 
@@ -212,9 +211,10 @@ public class CallExpressionResolver {
                 context.trace, "trace to resolve as local variable or property", nameExpression);
         CallResolver callResolver = expressionTypingServices.getCallResolver();
         Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
-        OverloadResolutionResults<VariableDescriptor> resolutionResult = callResolver.resolveSimpleProperty(
+        BasicCallResolutionContext contextForVariable = BasicCallResolutionContext.create(
-                BasicCallResolutionContext.create(context.replaceBindingTrace(traceForVariable), call, ResolveMode.TOP_LEVEL_CALL,
+                context.replaceBindingTrace(traceForVariable).replaceResolveMode(ResolveMode.TOP_LEVEL_CALL).
-                                                  CheckValueArgumentsMode.ENABLED, ResolutionResultsCache.create()));
+                        replaceResolutionResultsCache(), call, CheckValueArgumentsMode.ENABLED);
+        OverloadResolutionResults<VariableDescriptor> resolutionResult = callResolver.resolveSimpleProperty(contextForVariable);
         if (!resolutionResult.isNothing()) {
             traceForVariable.commit();
             checkSuper(receiver, resolutionResult, context.trace, nameExpression);
@@ -261,9 +261,9 @@ public class CallExpressionResolver {
 
         Call call = CallMaker.makeCall(nameExpression, receiver, callOperationNode, nameExpression, Collections.<ValueArgument>emptyList());
         TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function", nameExpression);
+        ResolutionContext newContext = context.replaceResolveMode(ResolveMode.TOP_LEVEL_CALL).replaceResolutionResultsCache();
         ResolvedCall<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(
-                call, nameExpression, context, ResolveMode.TOP_LEVEL_CALL, CheckValueArgumentsMode.ENABLED,
+                call, nameExpression, newContext, CheckValueArgumentsMode.ENABLED, result);
-                ResolutionResultsCache.create(), result);
         if (result[0]) {
             FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
             traceForFunction.commit();
@@ -280,12 +280,11 @@ public class CallExpressionResolver {
     @NotNull
     public JetTypeInfo getCallExpressionTypeInfo(
             @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
-            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode,
+            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context
-            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
         JetTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck(
-                callExpression, receiver, callOperationNode, context, resolveMode, resolutionResultsCache);
+                callExpression, receiver, callOperationNode, context);
-        if (resolveMode == ResolveMode.TOP_LEVEL_CALL) {
+        if (context.resolveMode == ResolveMode.TOP_LEVEL_CALL) {
             DataFlowUtils.checkType(typeInfo.getType(), callExpression, context, typeInfo.getDataFlowInfo());
         }
         return typeInfo;
@@ -294,16 +293,14 @@ public class CallExpressionResolver {
     @NotNull
     public JetTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck(
             @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
-            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode,
+            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context
-            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
         boolean[] result = new boolean[1];
         Call call = CallMaker.makeCall(receiver, callOperationNode, callExpression);
 
         TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function call", callExpression);
         ResolvedCallWithTrace<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(
-                call, callExpression, context.replaceBindingTrace(traceForFunction), resolveMode, CheckValueArgumentsMode.ENABLED,
+                call, callExpression, context.replaceBindingTrace(traceForFunction), CheckValueArgumentsMode.ENABLED, result);
-                resolutionResultsCache, result);
         if (result[0]) {
             FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
             traceForFunction.commit();
@@ -355,13 +352,11 @@ public class CallExpressionResolver {
             @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode,
             @NotNull JetExpression selectorExpression,
-            @NotNull ResolutionContext context,
+            @NotNull ResolutionContext context
-            @NotNull ResolveMode resolveMode,
-            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
         if (selectorExpression instanceof JetCallExpression) {
             return getCallExpressionTypeInfoWithoutFinalTypeCheck((JetCallExpression) selectorExpression, receiver,
-                                                                  callOperationNode, context, resolveMode, resolutionResultsCache);
+                                                                  callOperationNode, context);
         }
         else if (selectorExpression instanceof JetSimpleNameExpression) {
             return getSimpleNameExpressionTypeInfo((JetSimpleNameExpression) selectorExpression, receiver, callOperationNode, context);
@@ -370,7 +365,7 @@ public class CallExpressionResolver {
             JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression;
             JetExpression newReceiverExpression = qualifiedExpression.getReceiverExpression();
             JetTypeInfo newReceiverTypeInfo = getSelectorReturnTypeInfo(
-                    receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE), resolveMode, resolutionResultsCache);
+                    receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE));
             JetType newReceiverType = newReceiverTypeInfo.getType();
             DataFlowInfo newReceiverDataFlowInfo = newReceiverTypeInfo.getDataFlowInfo();
             JetExpression newSelectorExpression = qualifiedExpression.getSelectorExpression();
@@ -378,7 +373,7 @@ public class CallExpressionResolver {
                 ExpressionReceiver expressionReceiver = new ExpressionReceiver(newReceiverExpression, newReceiverType);
                 return getSelectorReturnTypeInfo(
                         expressionReceiver, qualifiedExpression.getOperationTokenNode(),
-                        newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo), resolveMode, resolutionResultsCache);
+                        newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo));
             }
         }
         else {
@@ -389,8 +384,7 @@ public class CallExpressionResolver {
 
     @NotNull
     public JetTypeInfo getQualifiedExpressionTypeInfo(
-            @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode,
+            @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context
-            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
         // TODO : functions as values
         JetExpression selectorExpression = expression.getSelectorExpression();
@@ -409,7 +403,7 @@ public class CallExpressionResolver {
 
         JetTypeInfo selectorReturnTypeInfo = getSelectorReturnTypeInfo(
                 new ExpressionReceiver(receiverExpression, receiverType),
-                expression.getOperationTokenNode(), selectorExpression, context, resolveMode, resolutionResultsCache);
+                expression.getOperationTokenNode(), selectorExpression, context);
         JetType selectorReturnType = selectorReturnTypeInfo.getType();
 
         //TODO move further
@@ -426,7 +420,7 @@ public class CallExpressionResolver {
             context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, selectorReturnType);
         }
         JetTypeInfo typeInfo = JetTypeInfo.create(selectorReturnType, selectorReturnTypeInfo.getDataFlowInfo());
-        if (resolveMode == ResolveMode.TOP_LEVEL_CALL) {
+        if (context.resolveMode == ResolveMode.TOP_LEVEL_CALL) {
             DataFlowUtils.checkType(typeInfo.getType(), expression, context, typeInfo.getDataFlowInfo());
         }
         return typeInfo;

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

@@ -40,10 +40,10 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
     }
     @NotNull
     public static BasicCallResolutionContext create(
-            @NotNull ResolutionContext context, @NotNull Call call, @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionContext context, @NotNull Call call, @NotNull CheckValueArgumentsMode checkArguments
-            @NotNull CheckValueArgumentsMode checkArguments, @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
-        return create(context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, resolveMode, checkArguments, context.expressionPosition, resolutionResultsCache);
+        return create(context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, context.resolveMode,
+                      checkArguments, context.expressionPosition, context.resolutionResultsCache);
     }
 
     private BasicCallResolutionContext(
@@ -60,9 +60,12 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
-        return create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache);
+        return create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition,
+                      resolutionResultsCache);
     }
 
     @Override

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

@@ -89,7 +89,9 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
         return new CallCandidateResolutionContext<D>(
                 candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode,
@@ -100,12 +102,4 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
     protected CallCandidateResolutionContext<D> self() {
         return this;
     }
-
-    @NotNull
-    public CallCandidateResolutionContext<D> replaceResolveMode(@NotNull ResolveMode newResolveMode) {
-        if (newResolveMode == resolveMode) return this;
-        return new CallCandidateResolutionContext<D>(
-                candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, newResolveMode,
-                checkArguments, expressionPosition, resolutionResultsCache);
-    }
 }

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

@@ -25,9 +25,7 @@ import org.jetbrains.jet.lang.types.JetType;
 
 public abstract class CallResolutionContext<Context extends CallResolutionContext<Context>> extends ResolutionContext<Context> {
     public final Call call;
-    public final ResolveMode resolveMode;
     public final CheckValueArgumentsMode checkArguments;
-    public final ResolutionResultsCache resolutionResultsCache;
 
     protected CallResolutionContext(
             @NotNull BindingTrace trace,
@@ -40,14 +38,12 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
             @NotNull ExpressionPosition expressionPosition,
             @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
-        super(trace, scope, expectedType, dataFlowInfo, expressionPosition);
+        super(trace, scope, expectedType, dataFlowInfo, expressionPosition, resolveMode, resolutionResultsCache);
         this.call = call;
-        this.resolveMode = resolveMode;
         this.checkArguments = checkArguments;
-        this.resolutionResultsCache = resolutionResultsCache;
     }
 
     public BasicCallResolutionContext toBasic() {
-        return BasicCallResolutionContext.create(this, call, resolveMode, checkArguments, resolutionResultsCache);
+        return BasicCallResolutionContext.create(this, call, checkArguments);
     }
 }

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

@@ -30,19 +30,25 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
     public final JetType expectedType;
     public final DataFlowInfo dataFlowInfo;
     public final ExpressionPosition expressionPosition;
+    public final ResolveMode resolveMode;
+    public final ResolutionResultsCache resolutionResultsCache;
 
     protected ResolutionContext(
             @NotNull BindingTrace trace,
             @NotNull JetScope scope,
             @NotNull JetType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
         this.trace = trace;
         this.scope = scope;
         this.expectedType = expectedType;
         this.dataFlowInfo = dataFlowInfo;
         this.expressionPosition = expressionPosition;
+        this.resolveMode = resolveMode;
+        this.resolutionResultsCache = resolutionResultsCache;
     }
 
     protected abstract Context create(
@@ -50,38 +56,57 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     );
     
     protected abstract Context self();
     
     public Context replaceBindingTrace(@NotNull BindingTrace trace) {
         if (this.trace == trace) return self();
-        return create(trace, scope, dataFlowInfo, expectedType, expressionPosition);
+        return create(trace, scope, dataFlowInfo, expectedType, expressionPosition, resolveMode, resolutionResultsCache);
     }
     
     @NotNull
     public Context replaceExpressionPosition(@NotNull ExpressionPosition expressionPosition) {
         if (expressionPosition == this.expressionPosition) return self();
-        return create(trace, scope, dataFlowInfo, expectedType, expressionPosition);
+        return create(trace, scope, dataFlowInfo, expectedType, expressionPosition, resolveMode, resolutionResultsCache);
     }
 
     @NotNull
     public Context replaceDataFlowInfo(@NotNull DataFlowInfo newDataFlowInfo) {
         if (newDataFlowInfo == dataFlowInfo) return self();
-        return create(trace, scope, newDataFlowInfo, expectedType, expressionPosition);
+        return create(trace, scope, newDataFlowInfo, expectedType, expressionPosition, resolveMode, resolutionResultsCache);
     }
 
     @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, expressionPosition);
+        return create(trace, scope, dataFlowInfo, newExpectedType, expressionPosition, resolveMode, resolutionResultsCache);
     }
 
     @NotNull
     public Context replaceScope(@NotNull JetScope newScope) {
         if (newScope == scope) return self();
-        return create(trace, newScope, dataFlowInfo, expectedType, expressionPosition);
+        return create(trace, newScope, dataFlowInfo, expectedType, expressionPosition, resolveMode, resolutionResultsCache);
+    }
+
+    @NotNull
+    public Context replaceResolveMode(@NotNull ResolveMode newResolveMode) {
+        if (newResolveMode == resolveMode) return self();
+        return create(trace, scope, dataFlowInfo, expectedType, expressionPosition, newResolveMode, resolutionResultsCache);
+    }
+
+    @NotNull
+    public Context replaceResolutionResultsCache(@NotNull ResolutionResultsCache newResolutionResultsCache) {
+        if (newResolutionResultsCache == resolutionResultsCache) return self();
+        return create(trace, scope, dataFlowInfo, expectedType, expressionPosition, resolveMode, newResolutionResultsCache);
+    }
+
+    @NotNull
+    public Context replaceResolutionResultsCache() {
+        return replaceResolutionResultsCache(ResolutionResultsCache.create());
     }
 }

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

@@ -12,9 +12,11 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
             @NotNull JetScope scope,
             @NotNull JetType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
-        super(trace, scope, expectedType, dataFlowInfo, expressionPosition);
+        super(trace, scope, expectedType, dataFlowInfo, expressionPosition, resolveMode, resolutionResultsCache);
     }
 
     @Override
@@ -23,9 +25,11 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
-        return new SimpleResolutionContext(trace, scope, expectedType, dataFlowInfo, expressionPosition);
+        return new SimpleResolutionContext(trace, scope, expectedType, dataFlowInfo, expressionPosition, resolveMode, resolutionResultsCache);
     }
 
     @Override

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

@@ -86,7 +86,9 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
         ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(
                 candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments,

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

@@ -666,7 +666,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         TemporaryBindingTrace traceWithReceiver = TemporaryBindingTrace.create(context.trace,
                 "trace to resolve callable reference with receiver", reference);
         FunctionDescriptor descriptor =
-                resolveCallableNotCheckingArguments(reference, receiver, context.replaceBindingTrace(traceWithReceiver), result);
+                resolveCallableNotCheckingArguments(
+                        reference, receiver, context.replaceBindingTrace(traceWithReceiver).replaceResolutionResultsCache(), result);
         if (result[0]) {
             traceWithReceiver.commit();
             return descriptor;
@@ -676,7 +677,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         TemporaryBindingTrace traceForStatic = TemporaryBindingTrace.create(context.trace,
                 "trace to resolve callable reference in static scope", reference);
         FunctionDescriptor possibleStaticNestedClassConstructor = resolveCallableNotCheckingArguments(reference, NO_RECEIVER,
-                context.replaceBindingTrace(traceForStatic).replaceScope(staticScope), result);
+                context.replaceBindingTrace(traceForStatic).replaceScope(staticScope).replaceResolutionResultsCache(), result);
         if (result[0]) {
             traceForStatic.commit();
             return possibleStaticNestedClassConstructor;
@@ -698,8 +699,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
         ExpressionTypingContext contextForResolve = context.replaceBindingTrace(trace).replaceExpectedType(NO_EXPECTED_TYPE);
         ResolvedCallWithTrace<FunctionDescriptor> function = contextForResolve.expressionTypingServices.getCallExpressionResolver()
-                .getResolvedCallForFunction(call, reference, contextForResolve, ResolveMode.TOP_LEVEL_CALL,
+                .getResolvedCallForFunction(call, reference, contextForResolve, CheckValueArgumentsMode.DISABLED, result);
-                                            CheckValueArgumentsMode.DISABLED, ResolutionResultsCache.create(), result);
         if (!result[0]) return null;
 
         if (function instanceof VariableAsFunctionResolvedCall) {
@@ -717,14 +717,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     public JetTypeInfo visitQualifiedExpression(JetQualifiedExpression expression, ExpressionTypingContext context) {
         CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver();
         return callExpressionResolver
-                .getQualifiedExpressionTypeInfo(expression, context, ResolveMode.TOP_LEVEL_CALL, ResolutionResultsCache.create());
+                .getQualifiedExpressionTypeInfo(expression, context);
     }
 
     @Override
     public JetTypeInfo visitCallExpression(JetCallExpression expression, ExpressionTypingContext context) {
         CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver();
-        return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context, ResolveMode.TOP_LEVEL_CALL,
+        return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context);
-                                                                ResolutionResultsCache.create());
     }
 
     @Override

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

@@ -38,8 +38,20 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition) {
+            @NotNull ExpressionPosition expressionPosition
-        return newContext(expressionTypingServices, new LabelResolver(), trace, scope, dataFlowInfo, expectedType, expressionPosition);
+    ) {
+        return newContext(expressionTypingServices, new LabelResolver(), trace, scope, dataFlowInfo, expectedType, expressionPosition,
+                          ResolveMode.TOP_LEVEL_CALL, ResolutionResultsCache.create());
+    }
+
+    @NotNull
+    public static ExpressionTypingContext newContext(
+            @NotNull ExpressionTypingServices expressionTypingServices,
+            @NotNull ResolutionContext resolutionContext
+    ) {
+        return newContext(expressionTypingServices, new LabelResolver(), resolutionContext.trace, resolutionContext.scope,
+                          resolutionContext.dataFlowInfo, resolutionContext.expectedType, resolutionContext.expressionPosition,
+                          resolutionContext.resolveMode, resolutionContext.resolutionResultsCache);
     }
 
     @NotNull
@@ -50,9 +62,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition) {
+            @NotNull ExpressionPosition expressionPosition,
-        return new ExpressionTypingContext(expressionTypingServices, 
+            @NotNull ResolveMode resolveMode,
-                                           labelResolver, trace, scope, dataFlowInfo, expectedType, expressionPosition);
+            @NotNull ResolutionResultsCache resolutionResultsCache
+    ) {
+        return new ExpressionTypingContext(
+                expressionTypingServices, labelResolver, trace, scope, dataFlowInfo, expectedType, expressionPosition, resolveMode, resolutionResultsCache);
     }
 
     public final ExpressionTypingServices expressionTypingServices;
@@ -68,8 +83,11 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition) {
+            @NotNull ExpressionPosition expressionPosition,
-        super(trace, scope, expectedType, dataFlowInfo, expressionPosition);
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
+    ) {
+        super(trace, scope, expectedType, dataFlowInfo, expressionPosition, resolveMode, resolutionResultsCache);
         this.expressionTypingServices = expressionTypingServices;
         this.labelResolver = labelResolver;
     }
@@ -80,9 +98,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @NotNull ExpressionPosition expressionPosition
+            @NotNull ExpressionPosition expressionPosition,
+            @NotNull ResolveMode resolveMode,
+            @NotNull ResolutionResultsCache resolutionResultsCache
     ) {
-        return new ExpressionTypingContext(expressionTypingServices, labelResolver, trace, scope, dataFlowInfo, expectedType, expressionPosition);
+        return new ExpressionTypingContext(expressionTypingServices, labelResolver, trace, scope, dataFlowInfo, expectedType,
+                                           expressionPosition, resolveMode, resolutionResultsCache);
     }
 
     @Override
@@ -104,8 +125,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
     @NotNull
     public OverloadResolutionResults<FunctionDescriptor> resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull Name name) {
         return expressionTypingServices.getCallResolver().resolveCallWithGivenName(
-                BasicCallResolutionContext.create(this, call, ResolveMode.TOP_LEVEL_CALL,
+                BasicCallResolutionContext.create(this, call, CheckValueArgumentsMode.ENABLED),
-                                                  CheckValueArgumentsMode.ENABLED, ResolutionResultsCache.create()),
                 functionReference,
                 name
         );

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

@@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
@@ -132,6 +133,11 @@ public class ExpressionTypingServices {
         return expressionTypingFacade.getTypeInfo(expression, context);
     }
 
+    @NotNull
+    public JetTypeInfo getTypeInfo(@NotNull JetExpression expression, @NotNull ResolutionContext resolutionContext) {
+        return expressionTypingFacade.getTypeInfo(expression, ExpressionTypingContext.newContext(this, resolutionContext));
+    }
+
     @Nullable
     public JetType getType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) {
         return getTypeInfo(scope, expression, expectedType, dataFlowInfo, trace).getType();
@@ -324,8 +330,8 @@ public class ExpressionTypingServices {
     }
 
     private ExpressionTypingContext createContext(ExpressionTypingContext oldContext, BindingTrace trace, WritableScope scope, DataFlowInfo dataFlowInfo, JetType expectedType) {
-        return ExpressionTypingContext.newContext(
+        return ExpressionTypingContext.newContext(this, oldContext.labelResolver, trace, scope, dataFlowInfo, expectedType,
-                this, oldContext.labelResolver, trace, scope, dataFlowInfo, expectedType, oldContext.expressionPosition);
+                                                  oldContext.expressionPosition, oldContext.resolveMode, oldContext.resolutionResultsCache);
     }
 
     @Nullable

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

@@ -209,7 +209,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
         //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, "trace to resolve array set method for binary expression", expression);
-        ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceBindingTrace(temporaryBindingTrace);
+        ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE)
+                .replaceBindingTrace(temporaryBindingTrace).replaceResolutionResultsCache();
 
         JetSimpleNameExpression operationSign = expression.getOperationReference();
         IElementType operationType = operationSign.getReferencedNameElementType();
@@ -238,14 +239,14 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
         Name name = OperatorConventions.ASSIGNMENT_OPERATIONS.get(operationType);
         TemporaryBindingTrace assignmentOperationTrace = TemporaryBindingTrace.create(context.trace, "trace to check assignment operation like '+=' for", expression);
         OverloadResolutionResults<FunctionDescriptor> assignmentOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall(
-                scope, name, context.replaceBindingTrace(assignmentOperationTrace), expression, receiver);
+                scope, name, context.replaceBindingTrace(assignmentOperationTrace).replaceResolutionResultsCache(), 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, "trace to check binary operation like '+' for", expression);
         OverloadResolutionResults<FunctionDescriptor> binaryOperationDescriptors = BasicExpressionTypingVisitor.getResolutionResultsForBinaryCall(
-                scope, counterpartName, context.replaceBindingTrace(binaryOperationTrace), expression, receiver);
+                scope, counterpartName, context.replaceBindingTrace(binaryOperationTrace).replaceResolutionResultsCache(), expression, receiver);
         JetType binaryOperationType = OverloadResolutionResultsUtil.getResultType(binaryOperationDescriptors);
 
         JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;