read kotlin supertypes in JavaDescriptorResolver

+ tests
+ remove jet.Any from supers

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

@@ -236,7 +236,7 @@ public class JavaDescriptorResolver {
         initializeTypeParameters(psiClass);
 
         // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
-        supertypes.addAll(getSupertypes(psiClass));
+        supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData.classDescriptor.getTypeConstructor().getParameters()));
 
         if (psiClass.isInterface()) {
             //classData.classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object
@@ -579,16 +579,60 @@ public class JavaDescriptorResolver {
         return typeParameterDescriptor;
     }
 
-    private Collection<? extends JetType> getSupertypes(PsiClass psiClass) {
+    private Collection<? extends JetType> getSupertypes(PsiClassWrapper psiClass, List<TypeParameterDescriptor> typeParameters) {
-        List<JetType> result = new ArrayList<JetType>();
+        final List<JetType> result = new ArrayList<JetType>();
-        result.add(JetStandardClasses.getAnyType());
+
-        transformSupertypeList(result, psiClass.getExtendsListTypes());
+        if (psiClass.getJetClass().signature().length() > 0) {
-        transformSupertypeList(result, psiClass.getImplementsListTypes());
+            final TypeParameterListTypeVariableResolver typeVariableResolver = new TypeParameterListTypeVariableResolver(typeParameters);
+            
+            new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() {
+                @Override
+                public JetSignatureVisitor visitFormalTypeParameter(String name, TypeInfoVariance variance, boolean reified) {
+                    // TODO: collect
+                    return new JetSignatureAdapter();
+                }
+
+                @Override
+                public JetSignatureVisitor visitSuperclass() {
+                    return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) {
+                        @Override
+                        protected void done(@NotNull JetType jetType) {
+                            if (!jetType.equals(JetStandardClasses.getAnyType())) {
+                                result.add(jetType);
+                            }
+                        }
+                    };
+                }
+
+                @Override
+                public JetSignatureVisitor visitInterface() {
+                    return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) {
+                        @Override
+                        protected void done(@NotNull JetType jetType) {
+                            if (!jetType.equals(JetStandardClasses.getAnyType())) {
+                                result.add(jetType);
+                            }
+                        }
+                    };
+                }
+            });
+        } else {
+            transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes());
+            transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes());
+        }
+        if (result.isEmpty()) {
+            result.add(JetStandardClasses.getAnyType());
+        }
         return result;
     }
 
     private void transformSupertypeList(List<JetType> result, PsiClassType[] extendsListTypes) {
         for (PsiClassType type : extendsListTypes) {
+            PsiClass resolved = type.resolve();
+            if (resolved != null && resolved.getQualifiedName().equals(JvmStdlibNames.JET_OBJECT.getFqName())) {
+                continue;
+            }
+            
             JetType transform = semanticServices.getTypeTransformer().transformToType(type);
 
             result.add(TypeUtils.makeNotNullable(transform));

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

@@ -4,6 +4,7 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiField;
 import com.intellij.psi.PsiMethod;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -56,4 +57,13 @@ public class PsiClassWrapper {
     public PsiClass getPsiClass() {
         return psiClass;
     }
+    
+    private JetClassAnnotation jetClass;
+    @NotNull
+    public JetClassAnnotation getJetClass() {
+        if (jetClass == null) {
+            jetClass = JetClassAnnotation.get(psiClass);
+        }
+        return jetClass;
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java

@@ -41,7 +41,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
         }
         return newSubstitutor;
     }
-    
+
     @NotNull
     @Override
     public TypeConstructor getTypeConstructor() {

compiler/testData/readKotlinBinaryClass/class/InheritClassSimple.kt

@@ -0,0 +1,5 @@
+package test
+
+abstract class Aaa()
+
+class Bbb() : Aaa()

compiler/testData/readKotlinBinaryClass/class/InheritClassWithParam.kt

@@ -0,0 +1,5 @@
+package test
+
+abstract class Aaa<P>()
+
+class Bbb() : Aaa<java.util.Random>()

compiler/testData/readKotlinBinaryClass/class/InheritTraitWithParam.kt

@@ -0,0 +1,5 @@
+package test
+
+trait Aaa<P>
+
+class Bbb() : Aaa<java.util.Random>

compiler/testData/readKotlinBinaryClass/classFun/FunInParamSuper.kt

@@ -0,0 +1,7 @@
+package test
+
+open class Base<T>() {
+    fun foo(): T = throw Exception()
+}
+
+class Inh() : Base<String>()

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

@@ -436,8 +436,12 @@ class NamespaceComparator {
                 serializeCommaSeparated(klass.getTypeConstructor().getParameters());
                 sb.append(">");
             }
+            
+            if (!klass.getTypeConstructor().getSupertypes().isEmpty()) {
+                sb.append(" : ");
+                new Serializer(sb).serializeCommaSeparated(new ArrayList<JetType>(klass.getTypeConstructor().getSupertypes()));
+            }
 
-            // TODO: supers
             // TODO: constructors
 
             sb.append(" {\n");