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

Typechecker tests added

Browse Source
This commit is contained in:
Andrey Breslav
2011-03-01 21:08:19 +03:00
parent 7b7fe4dd60
commit a327254187
3 changed files with 42 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/testData/resolve/Basic.jet
+4 -4
View File
@@ -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
}
idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
+38 -7
View File
@@ -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<String, Integer> declarationToPosition = new HashMap<String, Integer>();
private final Map<Integer, String> positionToReference = new HashMap<Integer, String>();
private final Map<Integer, String> positionToType = new HashMap<Integer, String>();
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<Integer, String> 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) {
idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java
-91
View File
@@ -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<JetDeclaration> 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.<TypeProjection>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.<TypeProjection>emptyList()).getFunctionGroup("plus");
// Collection<FunctionDescriptor> pluses = plusGroup.getPossiblyApplicableFunctions(Collections.<Type>emptyList(), Collections.singletonList(library.getIntType()));
// FunctionDescriptor intPlus = null;
// for (FunctionDescriptor plus : pluses) {
// intPlus = plus;
// }
// assertSame(intPlus, FunctionDescriptorUtil.getOriginal(mustBePlus));
// }
//
// {
// PropertyDescriptor a = classA.getMemberScope(Collections.<TypeProjection>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.<TypeProjection>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.<Type>emptyList(), Collections.<Type>emptyList());
assertNotNull(descriptorForFoo);
Type fooType = descriptorForFoo.getUnsubstitutedReturnType();
assertEquals(returnType, fooType);
}
}