diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java index b5c535dbac9..feb34c8b8d0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java +++ b/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()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java index 081b9188b50..55975a4a522 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java +++ b/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 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 results = callResolver.resolveFunctionCall(context.toCallResolutionContext(call)); + OverloadResolutionResults 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 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.emptyList()); TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function", nameExpression); - ResolvedCall resolvedCall = getResolvedCallForFunction(call, nameExpression, receiver, context, result); + ResolvedCall 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, - @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context) { - TypeInfoForCall typeInfoForCall = getCallExpressionExtendedTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context); + public TypeInfoForCall getCallExpressionExtendedTypeInfo( + @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, + @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 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(), - newSelectorExpression, context.replaceDataFlowInfo(newReceiverDataFlowInfo)); + return getSelectorReturnTypeInfo( + 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 diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index df0719a7ecd..1f42876cdae 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/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 getFunctionLiteralArguments() { return Collections.emptyList(); } - }, task.expectedType, task.dataFlowInfo, task.namespacesAllowed); + }, task.expectedType, task.dataFlowInfo, task.resolveMode, task.namespacesAllowed); OverloadResolutionResultsImpl resultsWithFunctionLiteralsStripped = performResolution(newTask, callTransformer, traceForResolutionCache); if (resultsWithFunctionLiteralsStripped.isSuccess() || resultsWithFunctionLiteralsStripped.isAmbiguity()) { task.tracing.danglingFunctionLiteralArgumentSuspected(task.trace, task.call.getFunctionLiteralArguments()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java index d114f97f2d0..2ca8432fe40 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java @@ -193,7 +193,7 @@ public class CallTransformer { 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 results = callResolver.resolveCallWithGivenName(basicCallResolutionContext, task.reference, Name.identifier("invoke")); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java index 4038183d936..4fd9a92ea6a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/BasicCallResolutionContext.java @@ -31,15 +31,16 @@ public class BasicCallResolutionContext extends CallResolutionContext @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 @NotNull ResolvedCallImpl candidateCall, @NotNull CallResolutionContext context, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) { return new CallCandidateResolutionContext(candidateCall, tracing, trace, context.scope, call, context.expectedType, - context.dataFlowInfo, context.namespacesAllowed, true); + context.dataFlowInfo, context.resolveMode, context.namespacesAllowed, true); } public static CallCandidateResolutionContext create( @@ -69,7 +70,7 @@ public final class CallCandidateResolutionContext @NotNull ResolvedCallImpl candidateCall, @NotNull BasicCallResolutionContext context, @NotNull TracingStrategy tracing ) { return new CallCandidateResolutionContext(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 @NotNull JetType expectedType, boolean namespacesAllowed ) { - return new CallCandidateResolutionContext(candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, - namespacesAllowed, false); + return new CallCandidateResolutionContext( + candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed, false); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java index aa826a3f3da..aa01508cfd5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java +++ b/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 extends ResolutionContext { public final Call call; + public final ResolveMode resolveMode; protected CallResolutionContext( BindingTrace trace, @@ -31,13 +32,15 @@ public abstract class CallResolutionContext { } @NotNull - public BasicCallResolutionContext toCallResolutionContext(@NotNull Call call) { - return BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed); + public BasicCallResolutionContext toCallResolutionContext(@NotNull Call call, @NotNull ResolveMode resolveMode) { + return BasicCallResolutionContext.create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed); } } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolveMode.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolveMode.java new file mode 100644 index 00000000000..a8ed7b02f32 --- /dev/null +++ b/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 +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java index b2480994cd3..bc1eefe7baa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TypeInfoForCall.java @@ -50,25 +50,14 @@ public class TypeInfoForCall { @NotNull DataFlowInfo dataFlowInfo, @NotNull ResolvedCall resolvedCall, @NotNull Call call, - @NotNull ResolutionContext context - ) { - 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 resolvedCall, - @Nullable Call call, - @Nullable ResolutionContext context + @NotNull ResolutionContext context, + @NotNull ResolveMode resolveMode ) { + JetTypeInfo typeInfo = JetTypeInfo.create(type, dataFlowInfo); CallCandidateResolutionContext 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) 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( diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTask.java index f59156033f8..b9fd73c83b3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTask.java +++ b/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 extends C public ResolutionTask( @NotNull Collection> candidates, @NotNull JetReferenceExpression reference, - BindingTrace trace, JetScope scope, Call call, JetType expectedType, DataFlowInfo dataFlowInfo, boolean namespacesAllowed) { - super(trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed); + BindingTrace trace, JetScope scope, Call call, JetType expectedType, DataFlowInfo dataFlowInfo, ResolveMode resolveMode, boolean namespacesAllowed) { + super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed); this.candidates = candidates; this.reference = reference; } public ResolutionTask(@NotNull Collection> 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 extends C return true; } - public ResolutionTask withTrace(BindingTrace newTrace) { - ResolutionTask newTask = new ResolutionTask(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo, namespacesAllowed); - newTask.setCheckingStrategy(checkingStrategy); - return newTask; - } - @Override protected ResolutionTask replace( @NotNull BindingTrace trace, @@ -105,7 +100,7 @@ public class ResolutionTask extends C @NotNull JetType expectedType, boolean namespacesAllowed ) { - ResolutionTask newTask = new ResolutionTask(candidates, reference, trace, scope, call, expectedType, dataFlowInfo, namespacesAllowed); + ResolutionTask newTask = new ResolutionTask(candidates, reference, trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed); newTask.setCheckingStrategy(checkingStrategy); return newTask; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java index 9a461536102..31a2abd2262 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java +++ b/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 { @@ -108,23 +102,8 @@ public class ExpressionTypingContext extends ResolutionContext resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull Name name) { - return expressionTypingServices.getCallResolver().resolveCallWithGivenName(makeResolutionContext(call), functionReference, name); - } - - @NotNull - public OverloadResolutionResults resolveFunctionCall(@NotNull Call call) { - return expressionTypingServices.getCallResolver().resolveFunctionCall(makeResolutionContext(call)); - } - - @NotNull - public OverloadResolutionResults resolveSimpleProperty(@NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) { - Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression); - return expressionTypingServices.getCallResolver().resolveSimpleProperty(makeResolutionContext(call)); + return expressionTypingServices.getCallResolver().resolveCallWithGivenName(toCallResolutionContext(call, ResolveMode.NORMAL), functionReference, name); } }