ReadClassDataTest, working on generics

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -134,7 +134,7 @@ public class FunctionCodegen {
                         av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_NULLABLE_FIELD, true);
                     }
                     if (jvmSignature.getKotlinParameterTypes() != null && jvmSignature.getKotlinParameterTypes().get(i) != null) {
-                        av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD, jvmSignature.getKotlinParameterTypes().get(i));
+                        av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD, jvmSignature.getKotlinParameterTypes().get(i + start));
                     }
                     av.visitEnd();
                 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -662,7 +662,7 @@ public class JavaDescriptorResolver {
         }
         
         JetType outType;
-        if (typeFromAnnotation != null) {
+        if (typeFromAnnotation != null && typeFromAnnotation.length() > 0) {
             outType = semanticServices.getTypeTransformer().transformToType(typeFromAnnotation);
         } else {
             outType = semanticServices.getTypeTransformer().transformToType(psiType);
@@ -858,7 +858,7 @@ public class JavaDescriptorResolver {
             }
         }
         JetType transformedType;
-        if (returnTypeFromAnnotation != null) {
+        if (returnTypeFromAnnotation != null && returnTypeFromAnnotation.length() > 0) {
             transformedType = semanticServices.getTypeTransformer().transformToType(returnTypeFromAnnotation);
         } else {
             transformedType = semanticServices.getTypeTransformer().transformToType(returnType);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java

@@ -131,6 +131,12 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
         };
     }
 
+    @Override
+    public void visitTypeVariable(String name, boolean nullable) {
+        // TODO: need a way to get type TypeParameterDescriptor by name
+        throw new IllegalStateException();
+    }
+
     @Override
     public void visitEnd() {
         JetType jetType = new JetTypeImpl(

compiler/tests/org/jetbrains/jet/ReadClassDataTest.java

@@ -107,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());
@@ -139,264 +140,290 @@ public class ReadClassDataTest extends UsefulTestCase {
     }
 
     private void compareClassifiers(@NotNull ClassifierDescriptor a, @NotNull ClassifierDescriptor b) {
-        String as = serializeContent((ClassDescriptor) a);
+        StringBuilder sba = new StringBuilder();
-        String bs = serializeContent((ClassDescriptor) b);
+        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.getModality(), sb);
-        sb.append(" ");
-        
-        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);
+        StringBuilder sba = new StringBuilder();
-        String bs = serialize(b);
+        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) {
+    private static class Serializer {
-        serialize(fun.getModality(), sb);
-        sb.append(" ");
 
-        sb.append("fun ");
+        protected final StringBuilder sb;
-        if (!fun.getTypeParameters().isEmpty()) {
+
-            sb.append("<");
+        public Serializer(StringBuilder sb) {
-            serializeCommaSeparated(fun.getTypeParameters(), sb);
+            this.sb = sb;
-            sb.append(">");
         }
 
-        if (fun.getReceiverParameter().exists()) {
+        private String serializeContent(ClassDescriptor klass) {
-            serialize(fun.getReceiverParameter(), sb);
-            sb.append(".");
-        }
 
-        sb.append(fun.getName());
+            serialize(klass.getModality());
-        sb.append("(");
+            sb.append(" ");
-        serializeCommaSeparated(fun.getValueParameters(), sb);
-        sb.append("): ");
-        serialize(fun.getReturnType(), sb);
-    }
 
-    private void serialize(ExtensionReceiver extensionReceiver, StringBuilder sb) {
+            serialize(klass.getKind());
-        serialize(extensionReceiver.getType(), sb);
+            sb.append(" ");
-    }
 
-    private void serialize(PropertyDescriptor prop, StringBuilder sb) {
+            serialize(klass);
-        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) {
+            if (!klass.getTypeConstructor().getParameters().isEmpty()) {
-        if (valueParameter.getVarargElementType() != null) {
+                sb.append("<");
-            sb.append("vararg ");
+                serializeCommaSeparated(klass.getTypeConstructor().getParameters());
-        }
+                sb.append(">");
-        sb.append(valueParameter.getName());
+            }
-        sb.append(": ");
-        if (valueParameter.getVarargElementType() != null) {
-            serialize(valueParameter.getVarargElementType(), sb);
-        } else {
-            serialize(valueParameter.getOutType(), sb);
-        }
-        if (valueParameter.hasDefaultValue()) {
-            sb.append(" = ?");
-        }
-    }
 
-    private void serialize(Variance variance, StringBuilder sb) {
+            // TODO: supers
-        if (variance == Variance.INVARIANT) {
+            // TODO: constructors
 
-        } else {
+            sb.append(" {\n");
-            sb.append(variance);
-            sb.append(' ');
-        }
-    }
 
-    private void serialize(Modality modality, StringBuilder sb) {
+            List<TypeProjection> typeArguments = new ArrayList<TypeProjection>();
-        sb.append(modality.name().toLowerCase());
+            for (TypeParameterDescriptor param : klass.getTypeConstructor().getParameters()) {
-    }
+                typeArguments.add(new TypeProjection(Variance.INVARIANT, param.getDefaultType()));
+            }
 
-    private void serialize(JetType type, StringBuilder sb) {
+            JetScope memberScope = klass.getMemberScope(typeArguments);
-        serialize(type.getConstructor().getDeclarationDescriptor(), sb);
+            for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
-        if (!type.getArguments().isEmpty()) {
+                // TODO
-            sb.append("<");
+                if (member.getName().equals("equals") || member.getName().equals("hashCode")
-            boolean first = true;
+                        || member.getName().equals("wait") || member.getName().equals("notify") || member.getName().equals("notifyAll")
-            for (TypeProjection proj : type.getArguments()) {
+                        || member.getName().equals("toString") || member.getName().equals("getClass")
-                serialize(proj.getProjectionKind(), sb);
+                        || member.getName().equals("clone") || member.getName().equals("finalize")
-                serialize(proj.getType(), sb);
+                        || member.getName().equals("getTypeInfo") || member.getName().equals("$setTypeInfo") || member.getName().equals("$typeInfo")
-                if (!first) {
+                        )
-                    sb.append(", ");
+                {
+                    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) {
+        private Method getMethodToSerialize(Object o) {
-        StringBuilder sb = new StringBuilder();
+            // TODO: cache
-        serialize(o, sb);
+            for (Method method : this.getClass().getMethods()) {
-        return sb.toString();
+                if (!method.getName().equals("serialize")) {
-    }
+                    continue;
-    
+                }
-    private void serializeCommaSeparated(List<?> list, StringBuilder sb) {
+                if (method.getParameterTypes().length != 1) {
-        serializeSeparated(list, sb, ", ");
+                    continue;
-    }
+                }
-
+                if (method.getParameterTypes()[0].equals(Object.class)) {
-    private void serializeSeparated(List<?> list, StringBuilder sb, String sep) {
+                    continue;
-        boolean first = true;
+                }
-        for (Object o : list) {
+                if (method.getParameterTypes()[0].isInstance(o)) {
-            if (!first) {
+                    method.setAccessible(true);
-                sb.append(sep);
+                    return method;
+                }
             }
-            serialize(o, sb);
+            throw new IllegalStateException("don't know how to serialize " + o + " (of " + o.getClass() + ")");
-            first = false;
         }
-    }
 
-    private Method getMethodToSerialize(Object o) {
+        public void serialize(Object o) {
-        // TODO: cache
+            Method method = getMethodToSerialize(o);
-        for (Method method : ReadClassDataTest.class.getDeclaredMethods()) {
+            invoke(method, this, o);
-            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;
-            }
         }
-        throw new IllegalStateException("don't know how to serialize " + o + " (of " + o.getClass() + ")");
-    }
 
-    private void serialize(Object o, StringBuilder sb) {
+        public void serialize(String s) {
-        Method method = getMethodToSerialize(o);
+            sb.append(s);
-        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;
         }
-        serialize(ns.getContainingDeclaration(), sb);
-        sb.append(".");
-        sb.append(ns.getName());
-    }
 
-    private void serialize(TypeParameterDescriptor param, StringBuilder sb) {
+        public void serialize(ModuleDescriptor module) {
-        serialize(param.getVariance(), sb);
+            // nop
-        sb.append(param.getName());
+        }
-        if (!param.getUpperBounds().isEmpty()) {
+
-            sb.append(" : ");
+        public void serialize(ClassDescriptor clazz) {
-            List<String> list = new ArrayList<String>();
+            serialize(clazz.getContainingDeclaration());
-            for (JetType upper : param.getUpperBounds()) {
+            sb.append(".");
-                list.add(serialize(upper));
+            sb.append(clazz.getName());
+        }
+
+        public void serialize(NamespaceDescriptor ns) {
+            if (ns.getContainingDeclaration() == null) {
+                // root ns
+                return;
             }
-            Collections.sort(list);
+            serialize(ns.getContainingDeclaration());
-            serializeSeparated(list, sb, " & "); // TODO: use where
+            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
     }
     
 

stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java

@@ -107,6 +107,10 @@ public class JetSignatureReader {
             int pos,
             final JetSignatureVisitor v)
     {
+        if (signature.length() == 0) {
+            throw new IllegalStateException();
+        }
+        
         char c;
         int start, end;
         boolean visited, inner;