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

logic for fake value arguments creation

Browse Source 
moved to 'resolveFakeCall' method
This commit is contained in:
Svetlana Isakova
2012-11-02 16:22:19 +04:00
parent 32391e217a
commit 82e9d1f4fa
4 changed files with 25 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java
+1 -6
View File
@@ -1089,13 +1089,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
if (right != null) {
ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context.replaceScope(context.scope));
final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(
context.expressionTypingServices.getProject(), "fakeArgument");
TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name);
traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, KotlinBuiltIns.getInstance().getNullableAnyType());
OverloadResolutionResults<FunctionDescriptor> resolutionResults = resolveFakeCall(
receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), Collections.<JetExpression>singletonList(fakeArgument), name);
context, receiver, name, KotlinBuiltIns.getInstance().getNullableAnyType());
if (resolutionResults.isSuccess()) {
FunctionDescriptor equals = resolutionResults.getResultingCall().getResultingDescriptor();
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java
+1 -1
View File
@@ -376,7 +376,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
@NotNull WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> resolvedCallKey
) {
OverloadResolutionResults<FunctionDescriptor> nextResolutionResults = resolveFakeCall(
new TransientReceiver(iteratorType), context, Collections.<JetExpression>emptyList(), Name.identifier(name));
new TransientReceiver(iteratorType), context, Name.identifier(name));
if (nextResolutionResults.isAmbiguity()) {
context.trace.report(ambiguity.on(loopRangeExpression, iteratorType));
}
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java
+19 -3
View File
@@ -16,6 +16,7 @@
package org.jetbrains.jet.lang.types.expressions;
import com.google.common.collect.Lists;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Pair;
import com.intellij.psi.PsiElement;
@@ -271,14 +272,29 @@ public class ExpressionTypingUtils {
return typeNames;
}
@NotNull
public static OverloadResolutionResults<FunctionDescriptor> resolveFakeCall(
@NotNull ExpressionTypingContext context, @NotNull ReceiverValue receiver,
@NotNull Name name, @NotNull JetType... argumentTypes
) {
TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name);
int index = 0;
List<JetExpression> fakeArguments = Lists.newArrayList();
for (JetType type : argumentTypes) {
final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(context.expressionTypingServices.getProject(), "fakeArgument" + index++);
fakeArguments.add(fakeArgument);
traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, type);
}
return makeAndResolveFakeCall(receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), fakeArguments, name).getSecond();
}
@NotNull
public static OverloadResolutionResults<FunctionDescriptor> resolveFakeCall(
@NotNull ReceiverValue receiver,
@NotNull ExpressionTypingContext context,
@NotNull List<JetExpression> valueArguments,
@NotNull Name name
) {
return makeAndResolveFakeCall(receiver, context, valueArguments, name).getSecond();
return makeAndResolveFakeCall(receiver, context, Collections.<JetExpression>emptyList(), name).getSecond();
}
@NotNull
@@ -320,7 +336,7 @@ public class ExpressionTypingUtils {
JetType expectedType = getExpectedTypeForComponent(context, entry);
OverloadResolutionResults<FunctionDescriptor> results =
resolveFakeCall(receiver, context.replaceExpectedType(expectedType), Collections.<JetExpression>emptyList(), componentName);
resolveFakeCall(receiver, context.replaceExpectedType(expectedType), componentName);
JetType componentType = null;
if (results.isSuccess()) {
compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java
+4 -20
View File
@@ -16,7 +16,6 @@
package org.jetbrains.jet.resolve;
import com.google.common.collect.Lists;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.project.Project;
import com.intellij.psi.JavaPsiFacade;
@@ -32,12 +31,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.psi.JetReferenceExpression;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
@@ -58,7 +53,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.jetbrains.jet.lang.resolve.BindingContext.EXPRESSION_TYPE;
import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.resolveFakeCall;
/**
@@ -140,26 +134,15 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
@NotNull
private FunctionDescriptor standardFunction(ClassDescriptor classDescriptor, String name, JetType... parameterTypes) {
List<JetType> parameterTypeList = Arrays.asList(parameterTypes);
TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(new BindingTraceContext(),
"trace to store fake argument for", name);
int index = 0;
List<JetExpression> valueArguments = Lists.newArrayList();
for (JetType type : parameterTypeList) {
final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(getProject(), "fakeArgument" + index++);
valueArguments.add(fakeArgument);
traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, type);
}
ExpressionTypingServices expressionTypingServices = new InjectorForTests(getProject()).getExpressionTypingServices();
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices, traceWithFakeArgumentInfo, classDescriptor.getDefaultType().getMemberScope(),
expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE, false);
OverloadResolutionResults<FunctionDescriptor> functions = resolveFakeCall(
ReceiverValue.NO_RECEIVER, context, valueArguments, Name.identifier(name));
context, ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypes);
for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {
List<ValueParameterDescriptor> unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters();
@@ -170,7 +153,8 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
}
}
}
throw new IllegalArgumentException("Not found: kotlin::" + classDescriptor.getName() + "." + name + "(" + parameterTypeList + ")");
throw new IllegalArgumentException("Not found: kotlin::" + classDescriptor.getName() + "." + name + "(" +
Arrays.toString(parameterTypes) + ")");
}
@Override