ReadKotlinBinaryClassTest: List<*>

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) {
+    public void writeTypeArgument(Variance variance) {
-        push(signatureVisitor().visitTypeArgument(c));
+        JetSignatureVariance jsVariance = toJetSignatureVariance(variance);
-        jetSignatureWriter.visitTypeArgument(c);
+        push(signatureVisitor().visitTypeArgument(jsVariance.getC()));
+        jetSignatureWriter.visitTypeArgument(jsVariance);
         generic = true;
     }
     

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();
                 }

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<TypeProjection>();
     }
 
-    private static Variance parseVariance(char wildcard) {
+    private static Variance parseVariance(JetSignatureVariance variance) {
-        switch (wildcard) {
+        switch (variance) {
-            case '=': return Variance.INVARIANT;
+            case INVARIANT: return Variance.INVARIANT;
-            case '+': return Variance.OUT_VARIANCE;
+            case OUT: return Variance.OUT_VARIANCE;
-            case '-': return Variance.IN_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));
             }
         };
     }

compiler/testData/readKotlinBinaryClass/prop/CollectionSize.kt

@@ -0,0 +1,6 @@
+package test
+
+import java.util.Collection
+
+val Collection<*>.anotherSize : Int
+    get() = size()

compiler/testData/readKotlinBinaryClass/type/ListOfStar.kt

@@ -0,0 +1,5 @@
+package test
+
+import java.util.List
+
+fun listOfStar(): List<*> = throw Exception()

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;>;

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("") ,
+    INVARIANT("", JetSignatureVariance.INVARIANT) ,
-    IN("in"),
+    IN("in", JetSignatureVariance.IN),
-    OUT("out");
+    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

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<TypeInfoProjection>();
         }
 
-        private static TypeInfoVariance parseVariance(char wildcard) {
+        private static TypeInfoVariance parseVariance(JetSignatureVariance variance) {
-            switch (wildcard) {
+            switch (variance) {
-                case '=': return TypeInfoVariance.INVARIANT;
+                case INVARIANT: return TypeInfoVariance.INVARIANT;
-                case '+': return TypeInfoVariance.OUT;
+                case OUT: return TypeInfoVariance.OUT;
-                case '-': return TypeInfoVariance.IN;
+                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

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;
     }
 

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();
     }
 

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;
                                 }
                             }

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();
+        }
+    }
+}

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.

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 != '=') {
+        if (variance.getC() != '=') {
-            buf.append(wildcard);
+            buf.append(variance.getC());
         }
         return this;
     }