azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added ResolveMode (NORMAL, INTERNAL) to CallResolutionContext

Browse Source
This commit is contained in:
Svetlana Isakova
2013-02-01 12:41:35 +04:00
parent bb003d2b2f
commit 4f5af9ab96
12 changed files with 93 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java
+3 -2
View File
@@ -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
+28 -19
View File
@@ -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,
@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<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(),
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
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
+3 -2
View File
@@ -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
+1 -1
View File
@@ -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
+5 -4
View File
@@ -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
+6 -5
View File
@@ -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,
namespacesAllowed, false);
return new CallCandidateResolutionContext<D>(
candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, namespacesAllowed, false);
}
@Override
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/CallResolutionContext.java
+4 -1
View File
@@ -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
+2 -2
View File
@@ -88,7 +88,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext> {
}
@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);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolveMode.java
+22
View File
@@ -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
+10 -16
View File
@@ -50,25 +50,14 @@ public class TypeInfoForCall {
@NotNull DataFlowInfo dataFlowInfo,
@NotNull ResolvedCall<FunctionDescriptor> 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<FunctionDescriptor> resolvedCall,
@Nullable Call call,
@Nullable ResolutionContext context
@NotNull ResolutionContext context,
@NotNull ResolveMode resolveMode
) {
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
+5 -10
View File
@@ -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) {
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<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
+4 -25
View File
@@ -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);
}
@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));
return expressionTypingServices.getCallResolver().resolveCallWithGivenName(toCallResolutionContext(call, ResolveMode.NORMAL), functionReference, name);
}
}