diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java b/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java index 66273168bdc..807971b9501 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java @@ -6,6 +6,7 @@ import org.jetbrains.jet.lang.resolve.java.JetSignatureUtils; import org.jetbrains.jet.lang.types.Variance; import org.jetbrains.jet.rt.signature.JetSignatureAdapter; import org.jetbrains.jet.rt.signature.JetSignatureReader; +import org.jetbrains.jet.rt.signature.JetSignatureVariance; import org.jetbrains.jet.rt.signature.JetSignatureWriter; import org.objectweb.asm.Type; import org.objectweb.asm.commons.Method; @@ -203,10 +204,20 @@ public class BothSignatureWriter { public void writeArrayEnd() { pop(); } + + private static JetSignatureVariance toJetSignatureVariance(Variance variance) { + switch (variance) { + case INVARIANT: return JetSignatureVariance.INVARIANT; + case IN_VARIANCE: return JetSignatureVariance.IN; + case OUT_VARIANCE: return JetSignatureVariance.OUT; + default: throw new IllegalStateException(); + } + } - public void writeTypeArgument(char c) { - push(signatureVisitor().visitTypeArgument(c)); - jetSignatureWriter.visitTypeArgument(c); + public void writeTypeArgument(Variance variance) { + JetSignatureVariance jsVariance = toJetSignatureVariance(variance); + push(signatureVisitor().visitTypeArgument(jsVariance.getC())); + jetSignatureWriter.visitTypeArgument(jsVariance); generic = true; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index ad5724d9ee8..5cd899e6ce6 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -298,7 +298,7 @@ public class JetTypeMapper { signatureVisitor.writeClassBegin(asmType.getInternalName(), jetType.isNullable()); for (TypeProjection proj : jetType.getArguments()) { // TODO: +- - signatureVisitor.writeTypeArgument('='); + signatureVisitor.writeTypeArgument(proj.getProjectionKind()); mapType(proj.getType(), kind, signatureVisitor, true); signatureVisitor.writeTypeArgumentEnd(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index c25d29a9360..687cb47eaa0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java @@ -12,6 +12,7 @@ import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.Variance; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; +import org.jetbrains.jet.rt.signature.JetSignatureVariance; import org.jetbrains.jet.rt.signature.JetSignatureVisitor; import java.util.ArrayList; @@ -108,22 +109,22 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd this.typeArguments = new ArrayList(); } - private static Variance parseVariance(char wildcard) { - switch (wildcard) { - case '=': return Variance.INVARIANT; - case '+': return Variance.OUT_VARIANCE; - case '-': return Variance.IN_VARIANCE; + private static Variance parseVariance(JetSignatureVariance variance) { + switch (variance) { + case INVARIANT: return Variance.INVARIANT; + case OUT: return Variance.OUT_VARIANCE; + case IN: return Variance.IN_VARIANCE; default: throw new IllegalStateException(); } } @Override - public JetSignatureVisitor visitTypeArgument(final char wildcard) { + public JetSignatureVisitor visitTypeArgument(final JetSignatureVariance variance) { return new JetTypeJetSignatureReader(javaSemanticServices, jetStandardLibrary, typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { - typeArguments.add(new TypeProjection(parseVariance(wildcard), jetType)); + typeArguments.add(new TypeProjection(parseVariance(variance), jetType)); } }; } diff --git a/compiler/testData/readKotlinBinaryClass/prop/CollectionSize.kt b/compiler/testData/readKotlinBinaryClass/prop/CollectionSize.kt new file mode 100644 index 00000000000..8ab57de53f1 --- /dev/null +++ b/compiler/testData/readKotlinBinaryClass/prop/CollectionSize.kt @@ -0,0 +1,6 @@ +package test + +import java.util.Collection + +val Collection<*>.anotherSize : Int + get() = size() diff --git a/compiler/testData/readKotlinBinaryClass/type/ListOfStar.kt b/compiler/testData/readKotlinBinaryClass/type/ListOfStar.kt new file mode 100644 index 00000000000..572fa54fff4 --- /dev/null +++ b/compiler/testData/readKotlinBinaryClass/type/ListOfStar.kt @@ -0,0 +1,5 @@ +package test + +import java.util.List + +fun listOfStar(): List<*> = throw Exception() diff --git a/compiler/testData/writeSignature/ListOfStar.kt b/compiler/testData/writeSignature/ListOfStar.kt new file mode 100644 index 00000000000..41d0aa3c844 --- /dev/null +++ b/compiler/testData/writeSignature/ListOfStar.kt @@ -0,0 +1,8 @@ +import java.util.List + +fun listOfStar(): List<*> = throw Exception() + +// method: namespace::listOfStar +// jvm signature: ()Ljava/util/List; +// generic signature: ()Ljava/util/List<+Ljava/lang/Object;>; +// kotlin signature: ()Ljava/util/List<+?Ljava/lang/Object;>; diff --git a/stdlib/src/jet/typeinfo/TypeInfoVariance.java b/stdlib/src/jet/typeinfo/TypeInfoVariance.java index 647bb6693a9..ed35747dc35 100644 --- a/stdlib/src/jet/typeinfo/TypeInfoVariance.java +++ b/stdlib/src/jet/typeinfo/TypeInfoVariance.java @@ -1,17 +1,21 @@ package jet.typeinfo; +import org.jetbrains.jet.rt.signature.JetSignatureVariance; + /** * @author alex.tkachman */ public enum TypeInfoVariance { - INVARIANT("") , - IN("in"), - OUT("out"); + INVARIANT("", JetSignatureVariance.INVARIANT) , + IN("in", JetSignatureVariance.IN), + OUT("out", JetSignatureVariance.OUT); private final String label; + private final JetSignatureVariance variance; - TypeInfoVariance(String label) { + TypeInfoVariance(String label, JetSignatureVariance variance) { this.label = label; + this.variance = variance; } @Override diff --git a/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java b/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java index 72003cd7b1e..b2075b7f4bc 100644 --- a/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java +++ b/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java @@ -6,6 +6,7 @@ import jet.typeinfo.TypeInfoProjection; import jet.typeinfo.TypeInfoVariance; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; import org.jetbrains.jet.rt.signature.JetSignatureReader; +import org.jetbrains.jet.rt.signature.JetSignatureVariance; import org.jetbrains.jet.rt.signature.JetSignatureVisitor; import java.lang.reflect.TypeVariable; @@ -176,17 +177,17 @@ class TypeInfoParser { this.projections = new ArrayList(); } - private static TypeInfoVariance parseVariance(char wildcard) { - switch (wildcard) { - case '=': return TypeInfoVariance.INVARIANT; - case '+': return TypeInfoVariance.OUT; - case '-': return TypeInfoVariance.IN; + private static TypeInfoVariance parseVariance(JetSignatureVariance variance) { + switch (variance) { + case INVARIANT: return TypeInfoVariance.INVARIANT; + case OUT: return TypeInfoVariance.OUT; + case IN: return TypeInfoVariance.IN; default: throw new IllegalStateException(); } } @Override - public JetSignatureVisitor visitTypeArgument(final char wildcard) { + public JetSignatureVisitor visitTypeArgument(final JetSignatureVariance wildcard) { final TypeInfoVariance variance = parseVariance(wildcard); return new SignatureParserJetSignatureAdapter(classLoader, signature) { @Override diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureAdapter.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureAdapter.java index 5d9878b3110..1f80071f63f 100644 --- a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureAdapter.java +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureAdapter.java @@ -76,7 +76,7 @@ public class JetSignatureAdapter implements JetSignatureVisitor { } @Override - public JetSignatureVisitor visitTypeArgument(char wildcard) { + public JetSignatureVisitor visitTypeArgument(JetSignatureVariance wildcard) { return this; } diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureExceptionsAdapter.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureExceptionsAdapter.java index 1d6be28930f..f65c34c6806 100644 --- a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureExceptionsAdapter.java +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureExceptionsAdapter.java @@ -82,7 +82,7 @@ public class JetSignatureExceptionsAdapter implements JetSignatureVisitor { } @Override - public JetSignatureVisitor visitTypeArgument(char wildcard) { + public JetSignatureVisitor visitTypeArgument(JetSignatureVariance wildcard) { throw new IllegalStateException(); } diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java index 900ec35d2e0..af581935e75 100644 --- a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java @@ -194,12 +194,12 @@ public class JetSignatureReader { case '-': pos = parseType(signature, pos + 1, - v.visitTypeArgument(c)); + v.visitTypeArgument(JetSignatureVariance.parseVariance(c))); break; default: pos = parseType(signature, pos, - v.visitTypeArgument('=')); + v.visitTypeArgument(JetSignatureVariance.INVARIANT)); break; } } diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureVariance.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureVariance.java new file mode 100644 index 00000000000..2adec59f1ef --- /dev/null +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureVariance.java @@ -0,0 +1,30 @@ +package org.jetbrains.jet.rt.signature; + +/** + * @author Stepan Koltsov + */ +public enum JetSignatureVariance { + INVARIANT('='), + IN('-'), + OUT('+'), + ; + + private final char c; + + private JetSignatureVariance(char c) { + this.c = c; + } + + public char getC() { + return c; + } + + public static JetSignatureVariance parseVariance(char c) { + switch (c) { + case '=': return INVARIANT; + case '+': return OUT; + case '-': return IN; + default: throw new IllegalStateException(); + } + } +} diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureVisitor.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureVisitor.java index 2a16f087c1c..a3548d8ce53 100644 --- a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureVisitor.java +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureVisitor.java @@ -134,7 +134,7 @@ public interface JetSignatureVisitor { * @param wildcard '+', '-' or '='. * @return a non null visitor to visit the signature of the type argument. */ - JetSignatureVisitor visitTypeArgument(char wildcard); + JetSignatureVisitor visitTypeArgument(JetSignatureVariance wildcard); /** * Ends the visit of a signature corresponding to a class or interface type. diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureWriter.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureWriter.java index 9db334ccefb..f7c6086fac9 100644 --- a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureWriter.java +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureWriter.java @@ -171,13 +171,13 @@ public class JetSignatureWriter implements JetSignatureVisitor { } @Override - public JetSignatureWriter visitTypeArgument(final char wildcard) { + public JetSignatureWriter visitTypeArgument(JetSignatureVariance variance) { if (argumentStack % 2 == 0) { ++argumentStack; buf.append('<'); } - if (wildcard != '=') { - buf.append(wildcard); + if (variance.getC() != '=') { + buf.append(variance.getC()); } return this; }