Extract JavaClassObjectResolver class from JavaClassResolver

Regenerate injectors

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
@@ -54,6 +55,7 @@ public class InjectorForJavaDescriptorResolver {
     private JavaClassResolver javaClassResolver;
     private JavaAnnotationResolver javaAnnotationResolver;
     private JavaCompileTimeConstResolver javaCompileTimeConstResolver;
+    private JavaClassObjectResolver javaClassObjectResolver;
     private JavaNamespaceResolver javaNamespaceResolver;
     private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
     private JavaConstructorResolver javaConstructorResolver;
@@ -80,6 +82,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
+        this.javaClassObjectResolver = new JavaClassObjectResolver();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
         this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
@@ -110,6 +113,7 @@ public class InjectorForJavaDescriptorResolver {
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
+        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setPsiClassFinder(psiClassFinder);
@@ -124,6 +128,11 @@ public class InjectorForJavaDescriptorResolver {
         javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
         javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
 
+        javaClassObjectResolver.setClassResolver(javaClassResolver);
+        javaClassObjectResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
+        javaClassObjectResolver.setTrace(bindingTrace);
+
         javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
@@ -54,6 +55,7 @@ public class InjectorForJavaSemanticServices {
     private JavaClassResolver javaClassResolver;
     private JavaAnnotationResolver javaAnnotationResolver;
     private JavaCompileTimeConstResolver javaCompileTimeConstResolver;
+    private JavaClassObjectResolver javaClassObjectResolver;
     private JavaNamespaceResolver javaNamespaceResolver;
     private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
     private JavaConstructorResolver javaConstructorResolver;
@@ -78,6 +80,7 @@ public class InjectorForJavaSemanticServices {
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
+        this.javaClassObjectResolver = new JavaClassObjectResolver();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
         this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
@@ -108,6 +111,7 @@ public class InjectorForJavaSemanticServices {
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
+        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setPsiClassFinder(psiClassFinder);
@@ -122,6 +126,11 @@ public class InjectorForJavaSemanticServices {
         javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
         javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
 
+        javaClassObjectResolver.setClassResolver(javaClassResolver);
+        javaClassObjectResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
+        javaClassObjectResolver.setTrace(bindingTrace);
+
         javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -51,6 +51,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
@@ -97,6 +98,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private JavaClassResolver javaClassResolver;
     private JavaAnnotationResolver javaAnnotationResolver;
     private JavaCompileTimeConstResolver javaCompileTimeConstResolver;
+    private JavaClassObjectResolver javaClassObjectResolver;
     private JavaNamespaceResolver javaNamespaceResolver;
     private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
     private JavaConstructorResolver javaConstructorResolver;
@@ -145,6 +147,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
+        this.javaClassObjectResolver = new JavaClassObjectResolver();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
         this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
@@ -265,6 +268,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
+        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setPsiClassFinder(psiClassFinder);
@@ -279,6 +283,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
         javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
 
+        javaClassObjectResolver.setClassResolver(javaClassResolver);
+        javaClassObjectResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
+        javaClassObjectResolver.setTrace(bindingTrace);
+
         javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);

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

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 
@@ -37,6 +38,8 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
+
 /**
  * @author Pavel Talanov
  */
@@ -132,4 +135,11 @@ public final class DescriptorResolverUtils {
             throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass: " + psiClass.getQualifiedName());
         }
     }
+
+    @NotNull
+    public static FqNameUnsafe getFqNameForClassObject(@NotNull PsiClass psiClass) {
+        String psiClassQualifiedName = psiClass.getQualifiedName();
+        assert psiClassQualifiedName != null : "Reading java class with no qualified name";
+        return new FqNameUnsafe(psiClassQualifiedName + "." + getClassObjectName(psiClass.getName()).getName());
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.resolver;
+
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
+import org.jetbrains.jet.lang.resolve.java.data.ResolverSyntheticClassObjectClassData;
+import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaClassMembersScope;
+import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameBase;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.Collections;
+
+import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
+import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
+import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
+
+public final class JavaClassObjectResolver {
+
+    private JavaClassResolver classResolver;
+    private JavaDescriptorResolver javaDescriptorResolver;
+    private BindingTrace trace;
+    private JavaSemanticServices semanticServices;
+
+    @Inject
+    public void setClassResolver(JavaClassResolver classResolver) {
+        this.classResolver = classResolver;
+    }
+
+    @Inject
+    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
+        this.javaDescriptorResolver = javaDescriptorResolver;
+    }
+
+    @Inject
+    public void setTrace(BindingTrace trace) {
+        this.trace = trace;
+    }
+
+    @Inject
+    public void setSemanticServices(JavaSemanticServices semanticServices) {
+        this.semanticServices = semanticServices;
+    }
+
+    @Nullable
+    public ResolverClassData createClassObjectDescriptor(
+            @NotNull ClassDescriptor containing,
+            @NotNull PsiClass psiClass
+    ) {
+        DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
+
+        if (psiClass.isEnum()) {
+            return createClassObjectDescriptorForEnum(containing, psiClass).getResolverBinaryClassData();
+        }
+
+        if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
+            return null;
+        }
+
+        // If there's at least one inner enum, we need to create a class object (to put this enum into)
+        for (PsiClass innerClass : psiClass.getInnerClasses()) {
+            if (DescriptorResolverUtils.isInnerEnum(innerClass, containing)) {
+                return createSyntheticClassObject(containing, psiClass).getResolverBinaryClassData();
+            }
+        }
+
+        PsiClass classObjectPsiClass = getInnerClassClassObject(psiClass);
+        if (classObjectPsiClass == null) {
+            return null;
+        }
+
+        final String qualifiedName = classObjectPsiClass.getQualifiedName();
+        assert qualifiedName != null;
+        FqName fqName = new FqName(qualifiedName);
+        ResolverClassData classData = new ClassDescriptorFromJvmBytecode(
+                containing, ClassKind.CLASS_OBJECT, classObjectPsiClass, fqName, javaDescriptorResolver)
+                .getResolverBinaryClassData();
+
+        ClassDescriptorFromJvmBytecode classObjectDescriptor = classData.getClassDescriptor();
+        classObjectDescriptor.setSupertypes(classResolver.getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData,
+                                                                        new ArrayList<TypeParameterDescriptor>(0)));
+        setUpClassObjectDescriptor(containing, fqName, classData, getClassObjectName(containing.getName()));
+        return classObjectDescriptor.getResolverBinaryClassData();
+    }
+
+    @NotNull
+    private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(
+            @NotNull ClassDescriptor containing,
+            @NotNull PsiClass psiClass
+    ) {
+        ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
+
+        classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
+        classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
+
+        return classObjectDescriptor;
+    }
+
+    @NotNull
+    private ClassDescriptorFromJvmBytecode createSyntheticClassObject(
+            @NotNull ClassDescriptor containing,
+            @NotNull PsiClass psiClass
+    ) {
+        FqNameUnsafe fqName = DescriptorResolverUtils.getFqNameForClassObject(psiClass);
+        ClassDescriptorFromJvmBytecode classObjectDescriptor = new ClassDescriptorFromJvmBytecode(
+                containing, ClassKind.CLASS_OBJECT, psiClass, null, javaDescriptorResolver);
+
+        ResolverSyntheticClassObjectClassData
+                data = new ResolverSyntheticClassObjectClassData(psiClass, null, classObjectDescriptor);
+        setUpClassObjectDescriptor(containing, fqName, data, getClassObjectName(containing.getName().getName()));
+
+        return classObjectDescriptor;
+    }
+
+    private void setUpClassObjectDescriptor(
+            @NotNull ClassDescriptor containing,
+            @NotNull FqNameBase fqName,
+            @NotNull ResolverClassData data,
+            @NotNull Name classObjectName
+    ) {
+        ClassDescriptorFromJvmBytecode classDescriptor = data.getClassDescriptor();
+        classDescriptor.setName(classObjectName);
+        classDescriptor.setModality(Modality.FINAL);
+        classDescriptor.setVisibility(containing.getVisibility());
+        classDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
+        classDescriptor.createTypeConstructor();
+        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(semanticServices, data);
+        WritableScopeImpl writableScope =
+                new WritableScopeImpl(classMembersScope, classDescriptor, RedeclarationHandler.THROW_EXCEPTION, fqName.toString());
+        writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
+        classDescriptor.setScopeForMemberLookup(writableScope);
+    }
+
+
+    @Nullable
+    private static PsiClass getInnerClassClassObject(@NotNull PsiClass outer) {
+        for (PsiClass inner : outer.getInnerClasses()) {
+            if (inner.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)) {
+                return inner;
+            }
+        }
+        return null;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -31,7 +31,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverBinaryClassData;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
-import org.jetbrains.jet.lang.resolve.java.data.ResolverSyntheticClassObjectClassData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassMembersScope;
@@ -40,9 +39,6 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameBase;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
@@ -54,11 +50,10 @@ import org.jetbrains.jet.rt.signature.JetSignatureReader;
 import org.jetbrains.jet.rt.signature.JetSignatureVisitor;
 
 import javax.inject.Inject;
-import java.util.*;
+import java.util.ArrayList;
-
+import java.util.Collection;
-import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
+import java.util.List;
-import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
+import java.util.Map;
-import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 
 public final class JavaClassResolver {
 
@@ -88,6 +83,7 @@ public final class JavaClassResolver {
     private PsiClassFinder psiClassFinder;
     private JavaNamespaceResolver namespaceResolver;
     private JavaTypeTransformer typeTransformer;
+    private JavaClassObjectResolver classObjectResolver;
 
     public JavaClassResolver() {
     }
@@ -107,6 +103,11 @@ public final class JavaClassResolver {
         this.signatureResolver = signatureResolver;
     }
 
+    @Inject
+    public void setClassObjectResolver(JavaClassObjectResolver classObjectResolver) {
+        this.classObjectResolver = classObjectResolver;
+    }
+
     @Inject
     public void setSemanticServices(JavaSemanticServices semanticServices) {
         this.semanticServices = semanticServices;
@@ -248,9 +249,11 @@ public final class JavaClassResolver {
         List<TypeParameterDescriptor> classTypeParameters = classDescriptor.getTypeConstructor().getParameters();
         supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData, classTypeParameters));
 
-        MutableClassDescriptorLite classObject = createClassObjectDescriptor(classDescriptor, psiClass);
+        ResolverClassData classObjectData = classObjectResolver.createClassObjectDescriptor(classDescriptor, psiClass);
-        if (classObject != null) {
+        classDescriptorCache.put(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectData);
-            classDescriptor.getBuilder().setClassObjectDescriptor(classObject);
+        if (classObjectData != null) {
+            ClassDescriptorFromJvmBytecode classObjectDescriptor = classObjectData.getClassDescriptor();
+            classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor);
         }
 
         classDescriptor.setAnnotations(annotationResolver.resolveAnnotations(psiClass, taskList));
@@ -290,104 +293,10 @@ public final class JavaClassResolver {
         }
     }
 
-    @Nullable
-    private MutableClassDescriptorLite createClassObjectDescriptor(
-            @NotNull ClassDescriptor containing,
-            @NotNull PsiClass psiClass
-    ) {
-        DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
-
-        if (psiClass.isEnum()) {
-            return createClassObjectDescriptorForEnum(containing, psiClass);
-        }
-
-        if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
-            return null;
-        }
-
-        // If there's at least one inner enum, we need to create a class object (to put this enum into)
-        for (PsiClass innerClass : psiClass.getInnerClasses()) {
-            if (DescriptorResolverUtils.isInnerEnum(innerClass, containing)) {
-                return createSyntheticClassObject(containing, psiClass);
-            }
-        }
-
-        PsiClass classObjectPsiClass = getInnerClassClassObject(psiClass);
-        if (classObjectPsiClass == null) {
-            return null;
-        }
-
-        final String qualifiedName = classObjectPsiClass.getQualifiedName();
-        assert qualifiedName != null;
-        FqName fqName = new FqName(qualifiedName);
-        ResolverClassData classData = new ClassDescriptorFromJvmBytecode(
-                containing, ClassKind.CLASS_OBJECT, classObjectPsiClass, fqName, javaDescriptorResolver)
-                .getResolverBinaryClassData();
-
-        ClassDescriptorFromJvmBytecode classObjectDescriptor = classData.getClassDescriptor();
-        classObjectDescriptor.setSupertypes(
-                getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData, new ArrayList<TypeParameterDescriptor>(0)));
-        setUpClassObjectDescriptor(containing, fqName, classData, getClassObjectName(containing.getName()));
-        return classObjectDescriptor;
-    }
-
-    private void setUpClassObjectDescriptor(
-            @NotNull ClassDescriptor containing,
-            @NotNull FqNameBase fqName,
-            @NotNull ResolverClassData data,
-            @NotNull Name classObjectName
-    ) {
-        ClassDescriptorFromJvmBytecode classDescriptor = data.getClassDescriptor();
-        classDescriptorCache.put(fqName, data);
-        classDescriptor.setName(classObjectName);
-        classDescriptor.setModality(Modality.FINAL);
-        classDescriptor.setVisibility(containing.getVisibility());
-        classDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
-        classDescriptor.createTypeConstructor();
-        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(semanticServices, data);
-        WritableScopeImpl writableScope =
-                new WritableScopeImpl(classMembersScope, classDescriptor, RedeclarationHandler.THROW_EXCEPTION, fqName.toString());
-        writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
-        classDescriptor.setScopeForMemberLookup(writableScope);
-    }
-
-    @NotNull
-    private MutableClassDescriptorLite createClassObjectDescriptorForEnum(
-            @NotNull ClassDescriptor containing,
-            @NotNull PsiClass psiClass
-    ) {
-        MutableClassDescriptorLite classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
-
-        classObjectDescriptor.getBuilder()
-                .addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
-        classObjectDescriptor.getBuilder()
-                .addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
-
-        return classObjectDescriptor;
-    }
-
-    @NotNull
-    private MutableClassDescriptorLite createSyntheticClassObject(
-            @NotNull ClassDescriptor containing,
-            @NotNull PsiClass psiClass
-    ) {
-        String psiClassQualifiedName = psiClass.getQualifiedName();
-        assert psiClassQualifiedName != null : "Reading java class with no qualified name";
-        FqNameUnsafe fqName = new FqNameUnsafe(psiClassQualifiedName + "." + getClassObjectName(psiClass.getName()).getName());
-        ClassDescriptorFromJvmBytecode classObjectDescriptor = new ClassDescriptorFromJvmBytecode(
-                containing, ClassKind.CLASS_OBJECT, psiClass, null, javaDescriptorResolver);
-
-        ResolverSyntheticClassObjectClassData
-                data = new ResolverSyntheticClassObjectClassData(psiClass, null, classObjectDescriptor);
-        setUpClassObjectDescriptor(containing, fqName, data, getClassObjectName(containing.getName().getName()));
-
-        return classObjectDescriptor;
-    }
-
     public Collection<JetType> getSupertypes(
-            PsiClassWrapper psiClass,
+            @NotNull PsiClassWrapper psiClass,
-            ResolverClassData classData,
+            @NotNull ResolverClassData classData,
-            List<TypeParameterDescriptor> typeParameters
+            @NotNull List<TypeParameterDescriptor> typeParameters
     ) {
         ClassDescriptor classDescriptor = classData.getClassDescriptor();
 
@@ -539,17 +448,6 @@ public final class JavaClassResolver {
         }
     }
 
-    @Nullable
-    private static PsiClass getInnerClassClassObject(@NotNull PsiClass outer) {
-        for (PsiClass inner : outer.getInnerClasses()) {
-            if (inner.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)) {
-                return inner;
-            }
-        }
-        return null;
-    }
-
-
     @Nullable
     public ClassDescriptor resolveClass(FqName name) {
         return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);