ReadKotlinBinaryClassTest: List<*>

2012-01-18 12:03:42 +04:00
parent 0229e725ab
commit 6ceb6816be
14 changed files with 95 additions and 29 deletions
@@ -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;
    }
    
@@ -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();
                }
@@ -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) {
-        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));
            }
        };
    }
@@ -0,0 +1,6 @@
+package test
+
+import java.util.Collection
+
+val Collection<*>.anotherSize : Int
+    get() = size()
@@ -0,0 +1,5 @@
+package test
+
+import java.util.List
+
+fun listOfStar(): List<*> = throw Exception()
@@ -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;>;
@@ -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
@@ -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) {
-            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
@@ -76,7 +76,7 @@ public class JetSignatureAdapter implements JetSignatureVisitor {
    }

    @Override
-    public JetSignatureVisitor visitTypeArgument(char wildcard) {
+    public JetSignatureVisitor visitTypeArgument(JetSignatureVariance wildcard) {
        return this;
    }

@@ -82,7 +82,7 @@ public class JetSignatureExceptionsAdapter implements JetSignatureVisitor {
    }

    @Override
-    public JetSignatureVisitor visitTypeArgument(char wildcard) {
+    public JetSignatureVisitor visitTypeArgument(JetSignatureVariance wildcard) {
        throw new IllegalStateException();
    }

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