added ResolveMode (NORMAL, INTERNAL) to CallResolutionContext

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

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
 import org.jetbrains.jet.lang.resolve.calls.context.TypeInfoForCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
@@ -172,10 +173,10 @@ public class ArgumentTypeResolver {
         TypeInfoForCall result = null;
         if (expression instanceof JetCallExpression) {
             result = callExpressionResolver.getCallExpressionExtendedTypeInfo(
-                    (JetCallExpression) expression, ReceiverValue.NO_RECEIVER, null, context);
+                    (JetCallExpression) expression, ReceiverValue.NO_RECEIVER, null, context, ResolveMode.INTERNAL);
         }
         if (expression instanceof JetQualifiedExpression) {
-            result = callExpressionResolver.getQualifiedExpressionExtendedTypeInfo((JetQualifiedExpression) expression, context);
+            result = callExpressionResolver.getQualifiedExpressionExtendedTypeInfo((JetQualifiedExpression) expression, context, ResolveMode.INTERNAL);
         }
         if (result != null) {
             recordExpressionType(expression, context, result.getTypeInfo());

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

@@ -48,6 +48,8 @@ import java.util.Collections;
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.*;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getStaticNestedClassesScope;
+
+import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
 
 public class CallExpressionResolver {
@@ -147,11 +149,11 @@ public class CallExpressionResolver {
     @Nullable
     private ResolvedCall<FunctionDescriptor> getResolvedCallForFunction(
             @NotNull Call call, @NotNull JetExpression callExpression, @NotNull ReceiverValue receiver,
-            @NotNull ResolutionContext context, @NotNull boolean[] result
+            @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode, @NotNull boolean[] result
     ) {
 
         CallResolver callResolver = expressionTypingServices.getCallResolver();
-        OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveFunctionCall(context.toCallResolutionContext(call));
+        OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveFunctionCall(context.toCallResolutionContext(call, resolveMode));
         if (!results.isNothing()) {
             checkSuper(receiver, results, context.trace, callExpression);
             result[0] = true;
@@ -173,7 +175,7 @@ public class CallExpressionResolver {
         CallResolver callResolver = expressionTypingServices.getCallResolver();
         Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
         OverloadResolutionResults<VariableDescriptor> resolutionResult = callResolver.resolveSimpleProperty(
-                context.replaceBindingTrace(traceForVariable).toCallResolutionContext(call));
+                context.replaceBindingTrace(traceForVariable).toCallResolutionContext(call, ResolveMode.NORMAL));
         if (!resolutionResult.isNothing()) {
             traceForVariable.commit();
             checkSuper(receiver, resolutionResult, context.trace, nameExpression);
@@ -217,7 +219,7 @@ 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);
-        ResolvedCall<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(call, nameExpression, receiver, context, result);
+        ResolvedCall<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(call, nameExpression, receiver, context, ResolveMode.NORMAL, result);
         if (result[0]) {
             FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
             traceForFunction.commit();
@@ -234,14 +236,16 @@ public class CallExpressionResolver {
     @NotNull
     public JetTypeInfo getCallExpressionTypeInfo(@NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context) {
-        JetTypeInfo typeInfo = getCallExpressionExtendedTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context).getTypeInfo();
+        JetTypeInfo typeInfo = getCallExpressionExtendedTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context, ResolveMode.NORMAL).getTypeInfo();
         return DataFlowUtils.checkType(typeInfo.getType(), callExpression, context, typeInfo.getDataFlowInfo());
     }
 
     @NotNull
-    public TypeInfoForCall getCallExpressionExtendedTypeInfo(@NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
+    public TypeInfoForCall getCallExpressionExtendedTypeInfo(
-            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context) {
+            @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
-        TypeInfoForCall typeInfoForCall = getCallExpressionExtendedTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context);
+            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode
+    ) {
+        TypeInfoForCall typeInfoForCall = getCallExpressionExtendedTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context, resolveMode);
         DataFlowUtils.checkType(typeInfoForCall.getType(), callExpression, context, typeInfoForCall.getDataFlowInfo());
         return typeInfoForCall;
     }
@@ -249,14 +253,14 @@ public class CallExpressionResolver {
     @NotNull
     private TypeInfoForCall getCallExpressionExtendedTypeInfoWithoutFinalTypeCheck(
             @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
-            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context
+            @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode
     ) {
         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);
         ResolvedCall<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(
-                call, callExpression, receiver, context.replaceBindingTrace(traceForFunction), result);
+                call, callExpression, receiver, context.replaceBindingTrace(traceForFunction), resolveMode, result);
         if (result[0]) {
             FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
             traceForFunction.commit();
@@ -270,7 +274,7 @@ public class CallExpressionResolver {
             }
             JetType type = functionDescriptor.getReturnType();
 
-            return TypeInfoForCall.create(type, resolvedCall.getDataFlowInfo(), resolvedCall, call, context);
+            return TypeInfoForCall.create(type, resolvedCall.getDataFlowInfo(), resolvedCall, call, context, resolveMode);
         }
 
         JetExpression calleeExpression = callExpression.getCalleeExpression();
@@ -308,11 +312,12 @@ public class CallExpressionResolver {
             @NotNull ReceiverValue receiver,
             @Nullable ASTNode callOperationNode,
             @NotNull JetExpression selectorExpression,
-            @NotNull ResolutionContext context
+            @NotNull ResolutionContext context,
+            @NotNull ResolveMode resolveMode
     ) {
         if (selectorExpression instanceof JetCallExpression) {
             return getCallExpressionExtendedTypeInfoWithoutFinalTypeCheck((JetCallExpression) selectorExpression, receiver,
-                                                                          callOperationNode, context);
+                                                                          callOperationNode, context, resolveMode);
         }
         else if (selectorExpression instanceof JetSimpleNameExpression) {
             return TypeInfoForCall.create(
@@ -321,14 +326,16 @@ public class CallExpressionResolver {
         else if (selectorExpression instanceof JetQualifiedExpression) {
             JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression;
             JetExpression newReceiverExpression = qualifiedExpression.getReceiverExpression();
-            TypeInfoForCall newReceiverTypeInfo = getSelectorReturnTypeInfo(receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE));
+            TypeInfoForCall newReceiverTypeInfo = getSelectorReturnTypeInfo(
+                    receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE), resolveMode);
             JetType newReceiverType = newReceiverTypeInfo.getType();
             DataFlowInfo newReceiverDataFlowInfo = newReceiverTypeInfo.getDataFlowInfo();
             JetExpression newSelectorExpression = qualifiedExpression.getSelectorExpression();
             if (newReceiverType != null && newSelectorExpression != null) {
                 ExpressionReceiver expressionReceiver = new ExpressionReceiver(newReceiverExpression, newReceiverType);
-                return getSelectorReturnTypeInfo(expressionReceiver, qualifiedExpression.getOperationTokenNode(),
+                return getSelectorReturnTypeInfo(
-                                                 newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo));
+                        expressionReceiver, qualifiedExpression.getOperationTokenNode(),
+                        newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo), resolveMode);
             }
         }
         else {
@@ -339,11 +346,13 @@ public class CallExpressionResolver {
 
     @NotNull
     public JetTypeInfo getQualifiedExpressionTypeInfo(@NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context) {
-        return getQualifiedExpressionExtendedTypeInfo(expression, context).getTypeInfo();
+        return getQualifiedExpressionExtendedTypeInfo(expression, context, ResolveMode.NORMAL).getTypeInfo();
     }
 
     @NotNull
-    public TypeInfoForCall getQualifiedExpressionExtendedTypeInfo(@NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context) {
+    public TypeInfoForCall getQualifiedExpressionExtendedTypeInfo(
+            @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode
+    ) {
         // TODO : functions as values
         JetExpression selectorExpression = expression.getSelectorExpression();
         JetExpression receiverExpression = expression.getReceiverExpression();
@@ -360,7 +369,7 @@ public class CallExpressionResolver {
         }
 
         TypeInfoForCall selectorReturnTypeInfo = getSelectorReturnTypeInfo(
-                new ExpressionReceiver(receiverExpression, receiverType), expression.getOperationTokenNode(), selectorExpression, context);
+                new ExpressionReceiver(receiverExpression, receiverType), expression.getOperationTokenNode(), selectorExpression, context, resolveMode);
         JetType selectorReturnType = selectorReturnTypeInfo.getType();
 
         //TODO move further

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

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.context.CallCandidateResolutionContext;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
 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.ResolvedCallWithTrace;
@@ -126,7 +127,7 @@ public class CallResolver {
             @NotNull JetType expectedType,
             @NotNull DataFlowInfo dataFlowInfo
     ) {
-        return resolveFunctionCall(BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, false));
+        return resolveFunctionCall(BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, ResolveMode.NORMAL, false));
     }
 
     @NotNull
@@ -497,7 +498,7 @@ public class CallResolver {
                             public List<JetExpression> getFunctionLiteralArguments() {
                                 return Collections.emptyList();
                             }
-                        }, task.expectedType, task.dataFlowInfo, task.namespacesAllowed);
+                        }, task.expectedType, task.dataFlowInfo, task.resolveMode, task.namespacesAllowed);
             OverloadResolutionResultsImpl<F> resultsWithFunctionLiteralsStripped = performResolution(newTask, callTransformer, traceForResolutionCache);
             if (resultsWithFunctionLiteralsStripped.isSuccess() || resultsWithFunctionLiteralsStripped.isAmbiguity()) {
                 task.tracing.danglingFunctionLiteralArgumentSuspected(task.trace, task.call.getFunctionLiteralArguments());

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

@@ -193,7 +193,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
 
             final DelegatingBindingTrace variableCallTrace = context.candidateCall.getTrace();
             BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create(
-                    variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo, context.namespacesAllowed);
+                    variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo, context.resolveMode, context.namespacesAllowed);
 
             // 'invoke' call resolve
             OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveCallWithGivenName(basicCallResolutionContext, task.reference, Name.identifier("invoke"));

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

@@ -31,15 +31,16 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull Call call,
             @NotNull JetType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull ResolveMode resolveMode,
             boolean namespacesAllowed
     ) {
-        return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
     }
 
     private BasicCallResolutionContext(
-            BindingTrace trace, JetScope scope, Call call, JetType expectedType, DataFlowInfo dataFlowInfo, boolean namespacesAllowed
+            BindingTrace trace, JetScope scope, Call call, JetType expectedType, DataFlowInfo dataFlowInfo, ResolveMode resolveMode, boolean namespacesAllowed
     ) {
-        super(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
     }
 
     @Override
@@ -50,7 +51,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
             @NotNull JetType expectedType,
             boolean namespacesAllowed
     ) {
-        return create(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        return create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
     }
 
     @Override

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

@@ -41,10 +41,11 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull Call call,
             @NotNull JetType expectedType,
             @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull ResolveMode resolveMode,
             boolean namespacesAllowed,
             boolean initialize
     ) {
-        super(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
         this.candidateCall = candidateCall;
         this.tracing = tracing;
         if (initialize) {
@@ -56,7 +57,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull ResolvedCallImpl<D> candidateCall, @NotNull CallResolutionContext context, @NotNull BindingTrace trace,
             @NotNull TracingStrategy tracing, @NotNull Call call) {
         return new CallCandidateResolutionContext<D>(candidateCall, tracing, trace, context.scope, call, context.expectedType,
-                                                        context.dataFlowInfo, context.namespacesAllowed, true);
+                                                        context.dataFlowInfo, context.resolveMode, context.namespacesAllowed, true);
     }
 
     public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> create(
@@ -69,7 +70,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull ResolvedCallImpl<D> candidateCall, @NotNull BasicCallResolutionContext context, @NotNull TracingStrategy tracing
     ) {
         return new CallCandidateResolutionContext<D>(candidateCall, tracing, context.trace, context.scope, context.call,
-                                                        context.expectedType, context.dataFlowInfo, context.namespacesAllowed, false);
+                                                        context.expectedType, context.dataFlowInfo, context.resolveMode, context.namespacesAllowed, false);
     }
 
     @Override
@@ -80,8 +81,8 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull JetType expectedType,
             boolean namespacesAllowed
     ) {
-        return new CallCandidateResolutionContext<D>(candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo,
+        return new CallCandidateResolutionContext<D>(
-                                                        namespacesAllowed, false);
+                candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed, false);
     }
 
     @Override

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

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.types.JetType;
 
 public abstract class CallResolutionContext<Context extends CallResolutionContext> extends ResolutionContext<Context> {
     public final Call call;
+    public final ResolveMode resolveMode;
 
     protected CallResolutionContext(
             BindingTrace trace,
@@ -31,13 +32,15 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
             Call call,
             JetType expectedType,
             DataFlowInfo dataFlowInfo,
+            ResolveMode resolveMode,
             boolean namespacesAllowed
     ) {
         super(trace, scope, expectedType, dataFlowInfo, namespacesAllowed);
         this.call = call;
+        this.resolveMode = resolveMode;
     }
 
     public BasicCallResolutionContext toBasic() {
-        return BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        return BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
     }
 }

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

@@ -88,7 +88,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext> {
     }
 
     @NotNull
-    public BasicCallResolutionContext toCallResolutionContext(@NotNull Call call) {
+    public BasicCallResolutionContext toCallResolutionContext(@NotNull Call call, @NotNull ResolveMode resolveMode) {
-        return BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        return BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
     }
 }

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.calls.context;
+
+public enum ResolveMode {
+    NORMAL,
+    INTERNAL
+}

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

@@ -50,25 +50,14 @@ public class TypeInfoForCall {
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ResolvedCall<FunctionDescriptor> resolvedCall,
             @NotNull Call call,
-            @NotNull ResolutionContext context
+            @NotNull ResolutionContext context,
-    ) {
+            @NotNull ResolveMode resolveMode
-        return create(JetTypeInfo.create(type, dataFlowInfo), resolvedCall, call, context);
-    }
-
-    public static TypeInfoForCall create(@NotNull JetTypeInfo typeInfo) {
-        return new TypeInfoForCall(typeInfo, null);
-    }
-
-    public static TypeInfoForCall create(
-            @NotNull JetTypeInfo typeInfo,
-            @Nullable ResolvedCall<FunctionDescriptor> resolvedCall,
-            @Nullable Call call,
-            @Nullable ResolutionContext context
     ) {
+        JetTypeInfo typeInfo = JetTypeInfo.create(type, dataFlowInfo);
         CallCandidateResolutionContext<FunctionDescriptor> callCandidateResolutionContext;
-        if (call != null && context != null && resolvedCall instanceof ResolvedCallImpl) {
+        if (resolvedCall instanceof ResolvedCallImpl) {
             BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create(
-                    TRACE_STUB, context.scope, call, TypeUtils.NO_EXPECTED_TYPE, typeInfo.getDataFlowInfo(), context.namespacesAllowed);
+                    TRACE_STUB, context.scope, call, TypeUtils.NO_EXPECTED_TYPE, typeInfo.getDataFlowInfo(), resolveMode, context.namespacesAllowed);
             callCandidateResolutionContext = CallCandidateResolutionContext.createForCallBeingAnalyzed(
                     (ResolvedCallImpl<FunctionDescriptor>) resolvedCall, basicCallResolutionContext, TracingStrategy.EMPTY);
         }
@@ -76,6 +65,11 @@ public class TypeInfoForCall {
             callCandidateResolutionContext = null;
         }
         return new TypeInfoForCall(typeInfo, callCandidateResolutionContext);
+
+    }
+
+    public static TypeInfoForCall create(@NotNull JetTypeInfo typeInfo) {
+        return new TypeInfoForCall(typeInfo, null);
     }
 
     public static TypeInfoForCall create(

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

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
 import org.jetbrains.jet.lang.resolve.calls.inference.InferenceErrorData;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
@@ -60,14 +61,14 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
 
     public ResolutionTask(
             @NotNull Collection<ResolutionCandidate<D>> candidates, @NotNull JetReferenceExpression reference,
-            BindingTrace trace, JetScope scope, Call call, JetType expectedType, DataFlowInfo dataFlowInfo, boolean namespacesAllowed) {
+            BindingTrace trace, JetScope scope, Call call, JetType expectedType, DataFlowInfo dataFlowInfo, ResolveMode resolveMode, boolean namespacesAllowed) {
-        super(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
         this.candidates = candidates;
         this.reference = reference;
     }
 
     public ResolutionTask(@NotNull Collection<ResolutionCandidate<D>> candidates, @NotNull JetReferenceExpression reference, @NotNull BasicCallResolutionContext context) {
-        this(candidates, reference, context.trace, context.scope, context.call, context.expectedType, context.dataFlowInfo, context.namespacesAllowed);
+        this(candidates, reference, context.trace, context.scope, context.call, context.expectedType, context.dataFlowInfo, context.resolveMode, context.namespacesAllowed);
     }
 
     @NotNull
@@ -91,12 +92,6 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
         return true;
     }
 
-    public ResolutionTask<D, F> withTrace(BindingTrace newTrace) {
-        ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
-        newTask.setCheckingStrategy(checkingStrategy);
-        return newTask;
-    }
-
     @Override
     protected ResolutionTask<D, F> replace(
             @NotNull BindingTrace trace,
@@ -105,7 +100,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
             @NotNull JetType expectedType,
             boolean namespacesAllowed
     ) {
-        ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(candidates, reference, trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
+        ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(candidates, reference, trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed);
         newTask.setCheckingStrategy(checkingStrategy);
         return newTask;
     }

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

@@ -16,24 +16,18 @@
 
 package org.jetbrains.jet.lang.types.expressions;
 
-import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.Call;
 import org.jetbrains.jet.lang.psi.JetReferenceExpression;
-import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
-import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext;
-import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext;
+import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
+import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 
 public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingContext> {
@@ -108,23 +102,8 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
 
 ////////// Call resolution utilities
 
-    private BasicCallResolutionContext makeResolutionContext(@NotNull Call call) {
-        return BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed);
-    }
-
     @NotNull
     public OverloadResolutionResults<FunctionDescriptor> resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull Name name) {
-        return expressionTypingServices.getCallResolver().resolveCallWithGivenName(makeResolutionContext(call), functionReference, name);
+        return expressionTypingServices.getCallResolver().resolveCallWithGivenName(toCallResolutionContext(call, ResolveMode.NORMAL), functionReference, name);
-    }
-
-    @NotNull
-    public OverloadResolutionResults<FunctionDescriptor> resolveFunctionCall(@NotNull Call call) {
-        return expressionTypingServices.getCallResolver().resolveFunctionCall(makeResolutionContext(call));
-    }
-
-    @NotNull
-    public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) {
-        Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
-        return expressionTypingServices.getCallResolver().resolveSimpleProperty(makeResolutionContext(call));
     }
 }