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

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
svtk
2011-12-26 18:37:27 +04:00
parent 36f50fa594 5653dabe95
commit 90e5c03389
467 changed files with 5068 additions and 2902 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/ReadClassDataTest.java
+260 -217
View File
@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
import org.jetbrains.jet.lang.types.JetType;
@@ -106,6 +107,7 @@ public class ReadClassDataTest extends UsefulTestCase {
jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdk(myTestRootDisposable);
jetCoreEnvironment.addToClasspath(tmpdir);
jetCoreEnvironment.addToClasspath(new File("out/production/stdlib"));
JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(jetCoreEnvironment.getProject());
JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), jetSemanticServices, new BindingTraceContext());
@@ -123,6 +125,8 @@ public class ReadClassDataTest extends UsefulTestCase {
if (ad instanceof ClassifierDescriptor) {
ClassifierDescriptor bd = nsb.getMemberScope().getClassifier(ad.getName());
compareClassifiers((ClassifierDescriptor) ad, bd);
Assert.assertNull(nsb.getMemberScope().getClassifier(ad.getName() + JvmAbi.TRAIT_IMPL_SUFFIX));
} else if (ad instanceof FunctionDescriptor) {
Set<FunctionDescriptor> functions = nsb.getMemberScope().getFunctions(ad.getName());
Assert.assertTrue(functions.size() >= 1);
@@ -136,251 +140,290 @@ public class ReadClassDataTest extends UsefulTestCase {
}
private void compareClassifiers(@NotNull ClassifierDescriptor a, @NotNull ClassifierDescriptor b) {
String as = serializeContent((ClassDescriptor) a);
String bs = serializeContent((ClassDescriptor) b);
StringBuilder sba = new StringBuilder();
StringBuilder sbb = new StringBuilder();
new Serializer(sba).serializeContent((ClassDescriptor) a);
new Serializer(sbb).serializeContent((ClassDescriptor) b);
String as = sba.toString();
String bs = sbb.toString();
Assert.assertEquals(as, bs);
System.out.println(as);
}
private String serializeContent(ClassDescriptor klass) {
StringBuilder sb = new StringBuilder();
serialize(klass.getKind(), sb);
sb.append(" ");
serialize(klass, sb);
if (!klass.getTypeConstructor().getParameters().isEmpty()) {
sb.append("<");
serializeCommaSeparated(klass.getTypeConstructor().getParameters(), sb);
sb.append(">");
}
// TODO: supers
// TODO: constructors
sb.append(" {\n");
List<TypeProjection> typeArguments = new ArrayList<TypeProjection>();
for (TypeParameterDescriptor param : klass.getTypeConstructor().getParameters()) {
typeArguments.add(new TypeProjection(Variance.INVARIANT, param.getDefaultType()));
}
JetScope memberScope = klass.getMemberScope(typeArguments);
for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
// TODO
if (member.getName().equals("equals") || member.getName().equals("hashCode")
|| member.getName().equals("wait") || member.getName().equals("notify") || member.getName().equals("notifyAll")
|| member.getName().equals("toString") || member.getName().equals("getClass")
|| member.getName().equals("clone") || member.getName().equals("finalize")
|| member.getName().equals("getTypeInfo") || member.getName().equals("$setTypeInfo") || member.getName().equals("$typeInfo")
)
{
continue;
}
sb.append(" ");
serialize(member, sb);
sb.append("\n");
}
sb.append("}\n");
return sb.toString();
}
private void serialize(ClassKind kind, StringBuilder sb) {
switch (kind) {
case CLASS:
sb.append("class");
break;
case TRAIT:
sb.append("trait");
break;
default:
throw new IllegalStateException();
}
}
private void compareFunctions(@NotNull FunctionDescriptor a, @NotNull FunctionDescriptor b) {
String as = serialize(a);
String bs = serialize(b);
StringBuilder sba = new StringBuilder();
StringBuilder sbb = new StringBuilder();
new Serializer(sba).serialize(a);
new Serializer(sbb).serialize(b);
String as = sba.toString();
String bs = sbb.toString();
Assert.assertEquals(as, bs);
System.out.println(as);
}
private static Object invoke(Method method, Object thiz, Object... args) {
try {
return method.invoke(thiz, args);
} catch (Exception e) {
throw new RuntimeException("failed to invoke " + method + ": " + e, e);
}
}
private void serialize(FunctionDescriptor fun, StringBuilder sb) {
sb.append("fun ");
if (!fun.getTypeParameters().isEmpty()) {
sb.append("<");
serializeCommaSeparated(fun.getTypeParameters(), sb);
sb.append(">");
private static class Serializer {
protected final StringBuilder sb;
public Serializer(StringBuilder sb) {
this.sb = sb;
}
if (fun.getReceiverParameter().exists()) {
serialize(fun.getReceiverParameter(), sb);
sb.append(".");
}
private String serializeContent(ClassDescriptor klass) {
sb.append(fun.getName());
sb.append("(");
serializeCommaSeparated(fun.getValueParameters(), sb);
sb.append("): ");
serialize(fun.getReturnType(), sb);
}
private void serialize(ExtensionReceiver extensionReceiver, StringBuilder sb) {
serialize(extensionReceiver.getType(), sb);
}
private void serialize(PropertyDescriptor prop, StringBuilder sb) {
if (prop.isVar()) {
sb.append("var ");
} else {
sb.append("val ");
}
sb.append(prop.getName());
sb.append(": ");
serialize(prop.getOutType(), sb);
}
private void serialize(ValueParameterDescriptor valueParameter, StringBuilder sb) {
sb.append(valueParameter.getName());
sb.append(": ");
if (valueParameter.getVarargElementType() != null) {
sb.append("vararg ");
serialize(valueParameter.getVarargElementType());
} else {
serialize(valueParameter.getOutType(), sb);
}
if (valueParameter.hasDefaultValue()) {
sb.append(" = ?");
}
}
private void serialize(Variance variance, StringBuilder sb) {
if (variance == Variance.INVARIANT) {
serialize(klass.getModality());
sb.append(" ");
} else {
sb.append(variance);
sb.append(' ');
}
}
private void serialize(JetType type, StringBuilder sb) {
serialize(type.getConstructor().getDeclarationDescriptor(), sb);
if (!type.getArguments().isEmpty()) {
sb.append("<");
boolean first = true;
for (TypeProjection proj : type.getArguments()) {
serialize(proj.getProjectionKind(), sb);
serialize(proj.getType(), sb);
if (!first) {
sb.append(", ");
serialize(klass.getKind());
sb.append(" ");
serialize(klass);
if (!klass.getTypeConstructor().getParameters().isEmpty()) {
sb.append("<");
serializeCommaSeparated(klass.getTypeConstructor().getParameters());
sb.append(">");
}
// TODO: supers
// TODO: constructors
sb.append(" {\n");
List<TypeProjection> typeArguments = new ArrayList<TypeProjection>();
for (TypeParameterDescriptor param : klass.getTypeConstructor().getParameters()) {
typeArguments.add(new TypeProjection(Variance.INVARIANT, param.getDefaultType()));
}
JetScope memberScope = klass.getMemberScope(typeArguments);
for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
// TODO
if (member.getName().equals("equals") || member.getName().equals("hashCode")
|| member.getName().equals("wait") || member.getName().equals("notify") || member.getName().equals("notifyAll")
|| member.getName().equals("toString") || member.getName().equals("getClass")
|| member.getName().equals("clone") || member.getName().equals("finalize")
|| member.getName().equals("getTypeInfo") || member.getName().equals("$setTypeInfo") || member.getName().equals("$typeInfo")
)
{
continue;
}
sb.append(" ");
new Serializer(sb).serialize(member);
sb.append("\n");
}
sb.append("}\n");
return sb.toString();
}
public void serialize(ClassKind kind) {
switch (kind) {
case CLASS:
sb.append("class");
break;
case TRAIT:
sb.append("trait");
break;
default:
throw new IllegalStateException();
}
}
private static Object invoke(Method method, Object thiz, Object... args) {
try {
return method.invoke(thiz, args);
} catch (Exception e) {
throw new RuntimeException("failed to invoke " + method + ": " + e, e);
}
}
public void serialize(FunctionDescriptor fun) {
serialize(fun.getModality());
sb.append(" ");
sb.append("fun ");
if (!fun.getTypeParameters().isEmpty()) {
sb.append("<");
serializeCommaSeparated(fun.getTypeParameters());
sb.append(">");
}
if (fun.getReceiverParameter().exists()) {
serialize(fun.getReceiverParameter());
sb.append(".");
}
sb.append(fun.getName());
sb.append("(");
new ValueParameterSerializer(sb).serializeCommaSeparated(fun.getValueParameters());
sb.append("): ");
serialize(fun.getReturnType());
}
public void serialize(ExtensionReceiver extensionReceiver) {
serialize(extensionReceiver.getType());
}
public void serialize(PropertyDescriptor prop) {
if (prop.isVar()) {
sb.append("var ");
} else {
sb.append("val ");
}
sb.append(prop.getName());
sb.append(": ");
serialize(prop.getOutType());
}
public void serialize(ValueParameterDescriptor valueParameter) {
if (valueParameter.getVarargElementType() != null) {
sb.append("vararg ");
}
sb.append(valueParameter.getName());
sb.append(": ");
if (valueParameter.getVarargElementType() != null) {
serialize(valueParameter.getVarargElementType());
} else {
serialize(valueParameter.getOutType());
}
if (valueParameter.hasDefaultValue()) {
sb.append(" = ?");
}
}
public void serialize(Variance variance) {
if (variance == Variance.INVARIANT) {
} else {
sb.append(variance);
sb.append(' ');
}
}
public void serialize(Modality modality) {
sb.append(modality.name().toLowerCase());
}
public void serialize(JetType type) {
serialize(type.getConstructor().getDeclarationDescriptor());
if (!type.getArguments().isEmpty()) {
sb.append("<");
boolean first = true;
for (TypeProjection proj : type.getArguments()) {
serialize(proj.getProjectionKind());
serialize(proj.getType());
if (!first) {
sb.append(", ");
}
first = false;
}
sb.append(">");
}
}
public void serializeCommaSeparated(List<?> list) {
serializeSeparated(list, ", ");
}
public void serializeSeparated(List<?> list, String sep) {
boolean first = true;
for (Object o : list) {
if (!first) {
sb.append(sep);
}
serialize(o);
first = false;
}
sb.append(">");
}
}
private String serialize(Object o) {
StringBuilder sb = new StringBuilder();
serialize(o, sb);
return sb.toString();
}
private void serializeCommaSeparated(List<?> list, StringBuilder sb) {
serializeSeparated(list, sb, ", ");
}
private void serializeSeparated(List<?> list, StringBuilder sb, String sep) {
boolean first = true;
for (Object o : list) {
if (!first) {
sb.append(sep);
private Method getMethodToSerialize(Object o) {
// TODO: cache
for (Method method : this.getClass().getMethods()) {
if (!method.getName().equals("serialize")) {
continue;
}
if (method.getParameterTypes().length != 1) {
continue;
}
if (method.getParameterTypes()[0].equals(Object.class)) {
continue;
}
if (method.getParameterTypes()[0].isInstance(o)) {
method.setAccessible(true);
return method;
}
}
serialize(o, sb);
first = false;
throw new IllegalStateException("don't know how to serialize " + o + " (of " + o.getClass() + ")");
}
}
private Method getMethodToSerialize(Object o) {
// TODO: cache
for (Method method : ReadClassDataTest.class.getDeclaredMethods()) {
if (!method.getName().equals("serialize")) {
continue;
}
if (method.getParameterTypes().length != 2) {
continue;
}
if (!method.getParameterTypes()[1].equals(StringBuilder.class)) {
continue;
}
if (method.getParameterTypes()[0].equals(Object.class)) {
continue;
}
if (method.getParameterTypes()[0].isInstance(o)) {
method.setAccessible(true);
return method;
}
public void serialize(Object o) {
Method method = getMethodToSerialize(o);
invoke(method, this, o);
}
throw new IllegalStateException("don't know how to serialize " + o + " (of " + o.getClass() + ")");
}
private void serialize(Object o, StringBuilder sb) {
Method method = getMethodToSerialize(o);
invoke(method, this, o, sb);
}
private void serialize(String s, StringBuilder sb) {
sb.append(s);
}
private void serialize(ModuleDescriptor module, StringBuilder sb) {
// nop
}
private void serialize(ClassDescriptor clazz, StringBuilder sb) {
serialize(clazz.getContainingDeclaration(), sb);
sb.append(".");
sb.append(clazz.getName());
}
private void serialize(NamespaceDescriptor ns, StringBuilder sb) {
if (ns.getContainingDeclaration() == null) {
// root ns
return;
public void serialize(String s) {
sb.append(s);
}
serialize(ns.getContainingDeclaration(), sb);
sb.append(".");
sb.append(ns.getName());
}
private void serialize(TypeParameterDescriptor param, StringBuilder sb) {
serialize(param.getVariance(), sb);
sb.append(param.getName());
if (!param.getUpperBounds().isEmpty()) {
sb.append(" : ");
List<String> list = new ArrayList<String>();
for (JetType upper : param.getUpperBounds()) {
list.add(serialize(upper));
}
Collections.sort(list);
serializeSeparated(list, sb, " & "); // TODO: use where
public void serialize(ModuleDescriptor module) {
// nop
}
public void serialize(ClassDescriptor clazz) {
serialize(clazz.getContainingDeclaration());
sb.append(".");
sb.append(clazz.getName());
}
public void serialize(NamespaceDescriptor ns) {
if (ns.getContainingDeclaration() == null) {
// root ns
return;
}
serialize(ns.getContainingDeclaration());
sb.append(".");
sb.append(ns.getName());
}
public void serialize(TypeParameterDescriptor param) {
serialize(param.getVariance());
sb.append(param.getName());
if (!param.getUpperBounds().isEmpty()) {
sb.append(" : ");
List<String> list = new ArrayList<String>();
for (JetType upper : param.getUpperBounds()) {
StringBuilder sb = new StringBuilder();
new Serializer(sb).serialize(upper);
list.add(sb.toString());
}
Collections.sort(list);
serializeSeparated(list, " & "); // TODO: use where
}
// TODO: lower bounds
}
}
private static class ValueParameterSerializer extends Serializer {
public ValueParameterSerializer(StringBuilder sb) {
super(sb);
}
@Override
public void serialize(TypeParameterDescriptor param) {
sb.append(param.getName());
}
// TODO: lower bounds
}
compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java
+2 -2
View File
@@ -54,7 +54,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
}
public void testBoth() throws Exception {
doTest(new TheTest("Unexpected TYPE_MISMATCH at 56 to 57", "Missing UNRESOLVED_REFERENCE at 166 to 168") {
doTest(new TheTest("Unexpected TYPE_MISMATCH at 56 to 57", "Missing UNRESOLVED_REFERENCE at 164 to 166") {
@Override
protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
diagnosedRanges.remove(1);
@@ -64,7 +64,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
}
public void testMissingInTheMiddle() throws Exception {
doTest(new TheTest("Unexpected NONE_APPLICABLE at 122 to 123", "Missing TYPE_MISMATCH at 161 to 169") {
doTest(new TheTest("Unexpected NONE_APPLICABLE at 120 to 121", "Missing TYPE_MISMATCH at 159 to 167") {
@Override
protected void makeTestData(List<Diagnostic> diagnostics, List<CheckerTestUtil.DiagnosedRange> diagnosedRanges) {
diagnosedRanges.remove(4);
compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java
-1
View File
@@ -10,7 +10,6 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.lang.Configuration;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
import org.jetbrains.jet.lang.psi.JetDeclaration;
compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java
+4
View File
@@ -235,4 +235,8 @@ public class ClassGenTest extends CodegenTestCase {
public void testKt707 () throws Exception {
blackBoxFile("regressions/kt707.jet");
}
public void testKt857 () throws Exception {
// blackBoxFile("regressions/kt857.jet");
}
}
compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java
+5
View File
@@ -236,6 +236,11 @@ public class ControlStructuresTest extends CodegenTestCase {
// System.out.println(generateToText());
}
public void testKt870() throws Exception {
blackBoxFile("regressions/kt870.jet");
// System.out.println(generateToText());
}
public void testQuicksort() throws Exception {
blackBoxFile("controlStructures/quicksort.jet");
// System.out.println(generateToText());
compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java
+2 -2
View File
@@ -485,7 +485,7 @@ public class NamespaceGenTest extends CodegenTestCase {
}
public void testTupleLiteral() throws Exception {
loadText("fun foo() = (1, \"foo\")");
loadText("fun foo() = #(1, \"foo\")");
// System.out.println(generateToText());
final Method main = generateFunction("foo");
Tuple2 tuple2 = (Tuple2) main.invoke(null);
@@ -494,7 +494,7 @@ public class NamespaceGenTest extends CodegenTestCase {
}
public void testParametrizedTupleLiteral() throws Exception {
loadText("fun <E,D> E.foo(extra: java.util.List<D>) = (1, \"foo\", this, extra)");
loadText("fun <E,D> E.foo(extra: java.util.List<D>) = #(1, \"foo\", this, extra)");
// System.out.println(generateToText());
final Method main = generateFunction();
Tuple4 tuple4 = (Tuple4) main.invoke(null, "aaa", TypeInfo.STRING_TYPE_INFO, TypeInfo.INT_TYPE_INFO, Arrays.asList(10));
compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java
+5 -5
View File
@@ -74,19 +74,19 @@ public class PatternMatchingTest extends CodegenTestCase {
}
public void testWildcardPattern() throws Exception {
loadText("fun foo(x: String) = when(x) { is * => \"something\" }");
loadText("fun foo(x: String) = when(x) { is * -> \"something\" }");
Method foo = generateFunction();
assertEquals("something", foo.invoke(null, ""));
}
public void testNoReturnType() throws Exception {
loadText("fun foo(x: String) = when(x) { is * => \"x\" }");
loadText("fun foo(x: String) = when(x) { is * -> \"x\" }");
Method foo = generateFunction();
assertEquals("x", foo.invoke(null, ""));
}
public void testTuplePattern() throws Exception {
loadText("fun foo(x: (Any, Any)) = when(x) { is (1,2) => \"one,two\"; else => \"something\" }");
loadText("fun foo(x: #(Any, Any)) = when(x) { is #(1,2) -> \"one,two\"; else -> \"something\" }");
Method foo = generateFunction();
final Object result;
try {
@@ -118,14 +118,14 @@ public class PatternMatchingTest extends CodegenTestCase {
}
public void testNames() throws Exception {
loadText("fun foo(x: (Any, Any)) = when(x) { is (val a is String, *) => a; else => \"something\" }");
loadText("fun foo(x: #(Any, Any)) = when(x) { is #(val a is String, *) -> a; else -> \"something\" }");
Method foo = generateFunction();
assertEquals("JetBrains", foo.invoke(null, new Tuple2<String, String>(null, "JetBrains", "s.r.o.")));
assertEquals("something", foo.invoke(null, new Tuple2<Integer, Integer>(null, 1, 2)));
}
public void testMultipleConditions() throws Exception {
loadText("fun foo(x: Any) = when(x) { is 0, 1 => \"bit\"; else => \"something\" }");
loadText("fun foo(x: Any) = when(x) { is 0, 1 -> \"bit\"; else -> \"something\" }");
Method foo = generateFunction();
assertEquals("bit", foo.invoke(null, 0));
assertEquals("bit", foo.invoke(null, 1));
compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+57 -57
View File
@@ -78,15 +78,15 @@ public class JetTypeCheckerTest extends JetLiteFixture {
assertType("\"d\"", library.getStringType());
assertType("\"\"\"d\"\"\"", library.getStringType());
assertType("()", JetStandardClasses.getUnitType());
assertType("#()", JetStandardClasses.getUnitType());
assertType("null", JetStandardClasses.getNullableNothingType());
}
public void testTupleConstants() throws Exception {
assertType("()", JetStandardClasses.getUnitType());
assertType("#()", JetStandardClasses.getUnitType());
assertType("(1, 'a')", JetStandardClasses.getTupleType(library.getIntType(), library.getCharType()));
assertType("#(1, 'a')", JetStandardClasses.getTupleType(library.getIntType(), library.getCharType()));
}
public void testTypeInfo() throws Exception {
@@ -117,11 +117,11 @@ public class JetTypeCheckerTest extends JetLiteFixture {
}
public void testWhen() throws Exception {
assertType("when (1) { is 1 => 2; } ", "Int");
assertType("when (1) { is 1 => 2; is 1 => '2'} ", "Any");
assertType("when (1) { is 1 => 2; is 1 => '2'; is 1 => null} ", "Any?");
assertType("when (1) { is 1 => 2; is 1 => '2'; else => null} ", "Any?");
assertType("when (1) { is 1 => 2; is 1 => '2'; is 1 => when(2) {is 1 => null}} ", "Any?");
assertType("when (1) { is 1 -> 2; } ", "Int");
assertType("when (1) { is 1 -> 2; is 1 -> '2'} ", "Any");
assertType("when (1) { is 1 -> 2; is 1 -> '2'; is 1 -> null} ", "Any?");
assertType("when (1) { is 1 -> 2; is 1 -> '2'; else -> null} ", "Any?");
assertType("when (1) { is 1 -> 2; is 1 -> '2'; is 1 -> when(2) {is 1 -> null}} ", "Any?");
}
public void testTry() throws Exception {
@@ -213,38 +213,38 @@ public class JetTypeCheckerTest extends JetLiteFixture {
}
public void testTuples() throws Exception {
assertSubtype("Unit", "()");
assertSubtype("()", "Unit");
assertSubtype("()", "()");
assertSubtype("Unit", "#()");
assertSubtype("#()", "Unit");
assertSubtype("#()", "#()");
assertSubtype("(Boolean)", "(Boolean)");
assertSubtype("(Byte)", "(Byte)");
assertSubtype("(Char)", "(Char)");
assertSubtype("(Short)", "(Short)");
assertSubtype("(Int)", "(Int)");
assertSubtype("(Long)", "(Long)");
assertSubtype("(Float)", "(Float)");
assertSubtype("(Double)", "(Double)");
assertSubtype("(Unit)", "(Unit)");
assertSubtype("(Unit, Unit)", "(Unit, Unit)");
assertSubtype("#(Boolean)", "#(Boolean)");
assertSubtype("#(Byte)", "#(Byte)");
assertSubtype("#(Char)", "#(Char)");
assertSubtype("#(Short)", "#(Short)");
assertSubtype("#(Int)", "#(Int)");
assertSubtype("#(Long)", "#(Long)");
assertSubtype("#(Float)", "#(Float)");
assertSubtype("#(Double)", "#(Double)");
assertSubtype("#(Unit)", "#(Unit)");
assertSubtype("#(Unit, Unit)", "#(Unit, Unit)");
assertSubtype("(Boolean)", "(Boolean)");
assertSubtype("(Byte)", "(Byte)");
assertSubtype("(Char)", "(Char)");
assertSubtype("(Short)", "(Short)");
assertSubtype("(Int)", "(Int)");
assertSubtype("(Long)", "(Long)");
assertSubtype("(Float)", "(Float)");
assertSubtype("(Double)", "(Double)");
assertSubtype("(Unit)", "(Unit)");
assertSubtype("(Unit, Unit)", "(Unit, Unit)");
assertSubtype("#(Boolean)", "#(Boolean)");
assertSubtype("#(Byte)", "#(Byte)");
assertSubtype("#(Char)", "#(Char)");
assertSubtype("#(Short)", "#(Short)");
assertSubtype("#(Int)", "#(Int)");
assertSubtype("#(Long)", "#(Long)");
assertSubtype("#(Float)", "#(Float)");
assertSubtype("#(Double)", "#(Double)");
assertSubtype("#(Unit)", "#(Unit)");
assertSubtype("#(Unit, Unit)", "#(Unit, Unit)");
assertNotSubtype("(Unit)", "(Int)");
assertNotSubtype("#(Unit)", "#(Int)");
assertSubtype("(Unit)", "(Any)");
assertSubtype("(Unit, Unit)", "(Any, Any)");
assertSubtype("(Unit, Unit)", "(Any, Unit)");
assertSubtype("(Unit, Unit)", "(Unit, Any)");
assertSubtype("#(Unit)", "#(Any)");
assertSubtype("#(Unit, Unit)", "#(Any, Any)");
assertSubtype("#(Unit, Unit)", "#(Any, Unit)");
assertSubtype("#(Unit, Unit)", "#(Unit, Any)");
}
public void testProjections() throws Exception {
@@ -326,38 +326,38 @@ public class JetTypeCheckerTest extends JetLiteFixture {
}
public void testLoops() throws Exception {
assertType("{ while (1) {1} }", "fun(): Unit");
assertType("{ do {1} while(1) }", "fun(): Unit");
assertType("{ for (i in 1) {1} }", "fun(): Unit");
assertType("{ while (1) {1} }", "() -> Unit");
assertType("{ do {1} while(1) }", "() -> Unit");
assertType("{ for (i in 1) {1} }", "() -> Unit");
}
public void testFunctionLiterals() throws Exception {
assertType("{() => }", "fun () : Unit");
assertType("{() : Int => }", "fun () : Int");
assertType("{() => 1}", "fun () : Int");
assertType("{() -> }", "() -> Unit");
assertType("{() : Int -> }", "() -> Int");
assertType("{() -> 1}", "() -> Int");
assertType("{(a : Int) => 1}", "fun (a : Int) : Int");
assertType("{(a : Int, b : String) => 1}", "fun (a : Int, b : String) : Int");
assertType("{(a : Int) -> 1}", "(a : Int) -> Int");
assertType("{(a : Int, b : String) -> 1}", "(a : Int, b : String) -> Int");
assertType("{(a : Int) => 1}", "fun (Int) : Int");
assertType("{(a : Int, b : String) => 1}", "fun (Int, String) : Int");
assertType("{(a : Int) -> 1}", "(Int) -> Int");
assertType("{(a : Int, b : String) -> 1}", "(Int, String) -> Int");
assertType("{Any.() => 1}", "fun Any.() : Int");
assertType("{Any.() -> 1}", "Any.() -> Int");
assertType("{Any.(a : Int) => 1}", "fun Any.(a : Int) : Int");
assertType("{Any.(a : Int, b : String) => 1}", "fun Any.(a : Int, b : String) : Int");
assertType("{Any.(a : Int) -> 1}", "Any.(a : Int) -> Int");
assertType("{Any.(a : Int, b : String) -> 1}", "Any.(a : Int, b : String) -> Int");
assertType("{Any.(a : Int) => 1}", "fun Any.(Int) : Int");
assertType("{Any.(a : Int, b : String) => 1}", "fun Any.(Int, String) : Int");
assertType("{Any.(a : Int) -> 1}", "Any.(Int) -> Int");
assertType("{Any.(a : Int, b : String) -> 1}", "Any.(Int, String) -> Int");
assertType("{Any.(a : Int, b : String) => b}", "fun Any.(Int, String) : String");
assertType("{Any.(a : Int, b : String) -> b}", "Any.(Int, String) -> String");
}
public void testBlocks() throws Exception {
assertType("if (1) {val a = 1; a} else {null}", "Int?");
assertType("if (1) {() => val a = 1; a} else {() => null}", "Function0<Int?>");
assertType("if (1) {() => val a = 1; a; var b : Boolean; b} else null", "Function0<Boolean>?");
assertType("if (1) {() => val a = 1; a; var b = a; b} else null", "Function0<Int>?");
assertType("if (1) {() -> val a = 1; a} else {() -> null}", "Function0<Int?>");
assertType("if (1) {() -> val a = 1; a; var b : Boolean; b} else null", "Function0<Boolean>?");
assertType("if (1) {() -> val a = 1; a; var b = a; b} else null", "Function0<Int>?");
}
public void testNew() throws Exception {
@@ -376,7 +376,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
public void testOverloads() throws Exception {
assertType("Functions<String>().f()", "Unit");
assertType("Functions<String>().f(1)", "Int");
assertType("Functions<Double>().f((1, 1))", "Double");
assertType("Functions<Double>().f(#(1, 1))", "Double");
assertType("Functions<Double>().f(1.0)", "Any");
assertType("Functions<Byte>().f<String>(\"\")", "Byte");
@@ -577,7 +577,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
"fun f() : Unit {} " +
"fun f(a : Int) : Int {} " +
"fun f(a : T) : Any {} " +
"fun f(a : (Int, Int)) : T {} " +
"fun f(a : #(Int, Int)) : T {} " +
"fun f<E>(a : E) : T {} " +
"}",
"class WithPredicate() { " +