diff --git a/idea/testData/resolve/Basic.jet b/idea/testData/resolve/Basic.jet index 53556723de2..845a5c7ae12 100644 --- a/idea/testData/resolve/Basic.jet +++ b/idea/testData/resolve/Basic.jet @@ -3,10 +3,10 @@ } - ~foo~fun foo(~foo.a~a : `std::Char`Char) = `foo.a`a - ~fooB~fun fooB() = `foo`foo('1') - ~foo.1~fun foo() : Int = 1.`std::Int.plus(Int)`plus(1) - ~foo1~fun foo1() : `B`B = new `B`B() + ~foo~fun foo(~foo.a~a : `std::Char`Char) = `foo.a`a`:std::Char` + ~fooB~fun fooB() = `foo`foo('1')`:std::Char` + ~foo.1~fun foo() : Int = 1.`std::Int.plus(Int)`plus(1)`:std::Int` + ~foo1~fun foo1() : `B`B = new `B`B()`:B` ~A.a~val a : `std::Int`Int } diff --git a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 1e21cdd8d67..a9149561d19 100644 --- a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -5,10 +5,7 @@ import com.intellij.openapi.editor.Document; import com.intellij.psi.PsiElement; import org.jetbrains.jet.lang.ErrorHandler; import org.jetbrains.jet.lang.JetSemanticServices; -import org.jetbrains.jet.lang.psi.JetDeclaration; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetReferenceExpression; -import org.jetbrains.jet.lang.psi.JetTypeReference; +import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; import org.jetbrains.jet.lang.types.*; @@ -30,6 +27,7 @@ public class ExpectedResolveData { private final Map declarationToPosition = new HashMap(); private final Map positionToReference = new HashMap(); + private final Map positionToType = new HashMap(); public ExpectedResolveData(final Document document) { new WriteCommandAction.Simple(null) { @@ -49,19 +47,25 @@ public class ExpectedResolveData { String group = matcher.group(); String name = group.substring(1, group.length() - 1); + int start = matcher.start(); if (group.startsWith("~")) { - if (declarationToPosition.put(name, matcher.start()) != null) { + if (declarationToPosition.put(name, start) != null) { throw new IllegalArgumentException("Redeclaration: " + name); } } else if (group.startsWith("`")) { - positionToReference.put(matcher.start(), name); + if (name.startsWith(":")) { + positionToType.put(start - 1, name.substring(1)); + } + else { + positionToReference.put(start, name); + } } else { throw new IllegalStateException(); } - document.replaceString(matcher.start(), matcher.end(), ""); + document.replaceString(start, matcher.end(), ""); text = document.getText(); } } @@ -126,6 +130,33 @@ public class ExpectedResolveData { "Reference `" + name + "`" + reference.getReferencedName() + " at " + reference.getTextOffset() + " is resolved into " + actualName + ".", expected, actual); } + + for (Map.Entry entry : positionToType.entrySet()) { + Integer position = entry.getKey(); + String typeName = entry.getValue(); + + PsiElement element = file.findElementAt(position); + JetExpression expression = getAncestorOfType(JetExpression.class, element); + + Type expressionType = bindingContext.getExpressionType(expression); + TypeConstructor expectedTypeConstructor; + if (typeName.startsWith("std::")) { + ClassDescriptor expectedClass = lib.getLibraryScope().getClass(typeName.substring(5)); + assertNotNull("Expected class not found: " + typeName); + expectedTypeConstructor = expectedClass.getTypeConstructor(); + } else { + Integer declarationPosition = declarationToPosition.get(typeName); + assertNotNull("Undeclared: " + typeName, declarationPosition); + PsiElement declElement = file.findElementAt(declarationPosition); + assertNotNull(declarationPosition); + JetDeclaration declaration = getAncestorOfType(JetDeclaration.class, declElement); + assertNotNull(declaration); + ClassDescriptor classDescriptor = bindingContext.getClassDescriptor((JetClass) declaration); + expectedTypeConstructor = classDescriptor.getTypeConstructor(); + } + + assertSame("At " + position + ": ", expectedTypeConstructor, expressionType.getConstructor()); + } } private DeclarationDescriptor standardFunction(ClassDescriptor classDescriptor, String name, Type parameterType) { diff --git a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java index b650c7ef94b..95a52094388 100644 --- a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -1,27 +1,18 @@ package org.jetbrains.jet.resolve; import com.intellij.openapi.application.PathManager; -import org.jetbrains.jet.lang.resolve.JetScope; -import org.jetbrains.jet.lang.resolve.OverloadDomain; -import org.jetbrains.jet.lang.resolve.OverloadResolver; -import org.jetbrains.jet.lang.types.FunctionDescriptor; -import org.jetbrains.jet.lang.types.JetStandardLibrary; -import org.jetbrains.jet.lang.types.Type; import org.jetbrains.jet.parsing.JetParsingTest; import java.io.File; -import java.util.Collections; /** * @author abreslav */ public class JetResolveTest extends ExtensibleResolveTestCase { - private JetStandardLibrary library; @Override public void setUp() throws Exception { super.setUp(); - library = new JetStandardLibrary(getProject()); } @Override @@ -35,88 +26,6 @@ public class JetResolveTest extends ExtensibleResolveTestCase { public void testBasic() throws Exception { doTest("/resolve/Basic.jet", true, true); -// JetFile jetFile = JetChangeUtil.createFile(getProject(), FileUtil.loadTextAndClose(new FileReader(getTestDataPath() + "/resolve/Basic.jet"))); -// List declarations = jetFile.getRootNamespace().getDeclarations(); -// BindingContext bindingContext = new TopDownAnalyzer(JetSemanticServices.createSemanticServices(library, ErrorHandler.THROW_EXCEPTION)).process(library.getLibraryScope(), declarations); -// -// JetClass classADecl = (JetClass) declarations.get(0); -// ClassDescriptor classA = bindingContext.getClassDescriptor(classADecl); -// assertNotNull(classA); -// -// JetScope membersOfA = classA.getMemberScope(Collections.emptyList()); -// ClassDescriptor classB = membersOfA.getClass("B"); -// assertNotNull(classB); -// -// { -// FunctionGroup fooFG = membersOfA.getFunctionGroup("foo"); -// assertFalse(fooFG.isEmpty()); -// } -// -// assertReturnType(membersOfA, "foo", library.getIntType()); -// assertReturnType(membersOfA, "foo1", new TypeImpl(classB)); -// assertReturnType(membersOfA, "fooB", library.getIntType()); -// -// JetFunction fooDecl = (JetFunction) classADecl.getDeclarations().get(1); -// Type expressionType = bindingContext.getExpressionType(fooDecl.getBodyExpression()); -// assertEquals(library.getIntType(), expressionType); -// -// { -// DeclarationDescriptor resolve = bindingContext.resolveReferenceExpression((JetReferenceExpression) fooDecl.getBodyExpression()); -// assertSame(bindingContext.getFunctionDescriptor(fooDecl).getUnsubstitutedValueParameters().get(0), resolve); -// } -// -// { -// JetFunction fooBDecl = (JetFunction) classADecl.getDeclarations().get(2); -// JetCallExpression fooBBody = (JetCallExpression) fooBDecl.getBodyExpression(); -// JetReferenceExpression refToFoo = (JetReferenceExpression) fooBBody.getCalleeExpression(); -// FunctionDescriptor mustBeFoo = (FunctionDescriptor) bindingContext.resolveReferenceExpression(refToFoo); -// assertSame(bindingContext.getFunctionDescriptor(fooDecl), FunctionDescriptorUtil.getOriginal(mustBeFoo)); -// } -// -// { -// JetFunction fooIntDecl = (JetFunction) classADecl.getDeclarations().get(3); -// JetCallExpression fooIntBody = (JetCallExpression) fooIntDecl.getBodyExpression(); -// JetDotQualifiedExpression qualifiedPlus = (JetDotQualifiedExpression) fooIntBody.getCalleeExpression(); -// JetReferenceExpression refToPlus = (JetReferenceExpression) qualifiedPlus.getSelectorExpression(); -// FunctionDescriptor mustBePlus = (FunctionDescriptor) bindingContext.resolveReferenceExpression(refToPlus); -// FunctionGroup plusGroup = library.getInt().getMemberScope(Collections.emptyList()).getFunctionGroup("plus"); -// Collection pluses = plusGroup.getPossiblyApplicableFunctions(Collections.emptyList(), Collections.singletonList(library.getIntType())); -// FunctionDescriptor intPlus = null; -// for (FunctionDescriptor plus : pluses) { -// intPlus = plus; -// } -// assertSame(intPlus, FunctionDescriptorUtil.getOriginal(mustBePlus)); -// } -// -// { -// PropertyDescriptor a = classA.getMemberScope(Collections.emptyList()).getProperty("a"); -// JetProperty aDecl = (JetProperty) classADecl.getDeclarations().get(5); -// PropertyDescriptor mustBeA = bindingContext.getPropertyDescriptor(aDecl); -// assertSame(a, mustBeA); -// -// JetTypeReference propertyTypeRef = aDecl.getPropertyTypeRef(); -// Type type = bindingContext.resolveTypeReference(propertyTypeRef); -// assertEquals(library.getIntType(), type); -// } -// -// JetClass classCDecl = (JetClass) declarations.get(1); -// ClassDescriptor classC = bindingContext.getClassDescriptor(classCDecl); -// assertNotNull(classC); -// assertEquals(1, classC.getTypeConstructor().getSupertypes().size()); -// assertEquals(classA.getTypeConstructor(), classC.getTypeConstructor().getSupertypes().iterator().next().getConstructor()); -// -// JetScope cScope = classC.getMemberScope(Collections.emptyList()); -// ClassDescriptor classC_B = cScope.getClass("B"); -// assertNotNull(classC_B); -// assertNotSame(classC_B, classB); -// assertEquals(classC.getTypeConstructor(), classC_B.getTypeConstructor().getSupertypes().iterator().next().getConstructor()); } - private void assertReturnType(JetScope membersOfA, String foo, Type returnType) { - OverloadDomain overloadsForFoo = OverloadResolver.INSTANCE.getOverloadDomain(null, membersOfA, foo); - FunctionDescriptor descriptorForFoo = overloadsForFoo.getFunctionDescriptorForPositionedArguments(Collections.emptyList(), Collections.emptyList()); - assertNotNull(descriptorForFoo); - Type fooType = descriptorForFoo.getUnsubstitutedReturnType(); - assertEquals(returnType, fooType); - } } \ No newline at end of file