Extract JavaClassObjectResolver class from JavaClassResolver

Regenerate injectors
2012-10-10 20:30:48 +04:00
parent c0b68684b8
commit 270079454b
6 changed files with 230 additions and 120 deletions
@@ -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);
@@ -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);
@@ -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);
@@ -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());
+    }
 }
@@ -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;
+    }
+}
@@ -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 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;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;

 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);
-        if (classObject != null) {
-            classDescriptor.getBuilder().setClassObjectDescriptor(classObject);
+        ResolverClassData classObjectData = classObjectResolver.createClassObjectDescriptor(classDescriptor, psiClass);
+        classDescriptorCache.put(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectData);
+        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,
-            ResolverClassData classData,
-            List<TypeParameterDescriptor> typeParameters
+            @NotNull PsiClassWrapper psiClass,
+            @NotNull ResolverClassData classData,
+            @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);