From a90db452ff14028454f17ef7fb134cb0dd9936a6 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Fri, 2 Nov 2012 15:47:04 +0400 Subject: [PATCH] resolveFakeCall instead of resolveExactSignature usage changed in tests --- .../jetbrains/jet/resolve/JetResolveTest.java | 56 ++++++++++++------- 1 file changed, 37 insertions(+), 19 deletions(-) diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 8e09c07ff8f..3d34597c6cb 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -16,6 +16,7 @@ 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; @@ -31,26 +32,35 @@ 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.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; +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; import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeProjection; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.parsing.JetParsingTest; import java.io.File; import java.util.Arrays; -import java.util.Collections; 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; + /** * @author abreslav */ @@ -70,11 +80,11 @@ public class JetResolveTest extends ExtensibleResolveTestCase { KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); Map nameToDescriptor = new HashMap(); nameToDescriptor.put("kotlin::Int.plus(Int)", standardFunction(builtIns.getInt(), "plus", builtIns.getIntType())); - FunctionDescriptor descriptorForGet = standardFunction(builtIns.getArray(), Collections.singletonList(new TypeProjection(builtIns.getIntType())), "get", builtIns.getIntType()); + FunctionDescriptor descriptorForGet = standardFunction(builtIns.getArray(), "get", builtIns.getIntType()); nameToDescriptor.put("kotlin::Array.get(Int)", descriptorForGet.getOriginal()); nameToDescriptor.put("kotlin::Int.compareTo(Double)", standardFunction(builtIns.getInt(), "compareTo", builtIns.getDoubleType())); @NotNull - FunctionDescriptor descriptorForSet = standardFunction(builtIns.getArray(), Collections.singletonList(new TypeProjection(builtIns.getIntType())), "set", builtIns.getIntType(), builtIns.getIntType()); + FunctionDescriptor descriptorForSet = standardFunction(builtIns.getArray(), "set", builtIns.getIntType(), builtIns.getIntType()); nameToDescriptor.put("kotlin::Array.set(Int, Int)", descriptorForSet.getOriginal()); Map nameToDeclaration = new HashMap(); @@ -129,25 +139,33 @@ public class JetResolveTest extends ExtensibleResolveTestCase { } @NotNull - private FunctionDescriptor standardFunction(ClassDescriptor classDescriptor, String name, JetType parameterType) { - List typeArguments = Collections.emptyList(); - return standardFunction(classDescriptor, typeArguments, name, parameterType); - } + private FunctionDescriptor standardFunction(ClassDescriptor classDescriptor, String name, JetType... parameterTypes) { + List parameterTypeList = Arrays.asList(parameterTypes); - @NotNull - private FunctionDescriptor standardFunction(ClassDescriptor classDescriptor, List typeArguments, String name, JetType... parameterType) { - List parameterTypeList = Arrays.asList(parameterType); -// JetTypeInferrer.Services typeInferrerServices = JetSemanticServices.createSemanticServices(getProject()).getTypeInferrerServices(new BindingTraceContext()); + TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(new BindingTraceContext(), + "trace to store fake argument for", name); + int index = 0; + List 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(), + DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE, false); + + OverloadResolutionResults functions = resolveFakeCall( + ReceiverValue.NO_RECEIVER, context, valueArguments, Name.identifier(name)); - CallResolver callResolver = new InjectorForTests(getProject()).getCallResolver(); - OverloadResolutionResults functions = callResolver.resolveExactSignature( - classDescriptor.getMemberScope(typeArguments), ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypeList); for (ResolvedCall resolvedCall : functions.getResultingCalls()) { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); - if (unsubstitutedValueParameter.getType().equals(parameterType[i])) { + if (unsubstitutedValueParameter.getType().equals(parameterTypes[i])) { return resolvedCall.getResultingDescriptor(); } }