Introduce EnumClassObjectDescriptor

Extract the duplicate logic in deserialization and descriptor.loader.java

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt

@@ -40,20 +40,15 @@ import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.jet.lang.types.TypeUtils
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor
 import org.jetbrains.jet.lang.descriptors.Modality
-import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl
-import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations
 import org.jetbrains.jet.lang.descriptors.ClassKind
-import org.jetbrains.jet.lang.resolve.DescriptorFactory
 import java.util.ArrayList
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor
-import org.jetbrains.jet.lang.resolve.name.SpecialNames
 import org.jetbrains.jet.lang.types.AbstractClassTypeConstructor
 import org.jetbrains.jet.lang.resolve.java.lazy.resolveTopLevelClassInModule
+import org.jetbrains.jet.lang.descriptors.impl.EnumClassObjectDescriptor
 
 class LazyJavaClassDescriptor(
         private val outerC: LazyJavaResolverContextWithTypes,
@@ -100,37 +95,11 @@ class LazyJavaClassDescriptor(
 
     private val _classObjectDescriptor = c.storageManager.createNullableLazyValue {
         if (jClass.isEnum()) {
-            val classObject = MutableClassDescriptor(this, this.getUnsubstitutedInnerClassesScope(), ClassKind.CLASS_OBJECT, false,
+            EnumClassObjectDescriptor(c.storageManager, this)
-                                                     SpecialNames.getClassObjectName(this.getName()))
-            classObject.setSupertypes(listOf(KotlinBuiltIns.getInstance().getAnyType()))
-            classObject.setModality(Modality.FINAL)
-            classObject.setVisibility(jClass.getVisibility())
-            classObject.setTypeParameterDescriptors(listOf())
-            classObject.createTypeConstructor()
-            classObject.setPrimaryConstructor(DescriptorFactory.createPrimaryConstructorForObject(classObject))
-
-            val scope = LazyJavaClassMemberScope(c, classObject, jClass, enumClassObject = true)
-            val writableScope = WritableScopeImpl(scope, classObject, RedeclarationHandler.THROW_EXCEPTION, "Enum class object scope")
-            writableScope.changeLockLevel(WritableScope.LockLevel.BOTH)
-
-            classObject.setScopeForMemberLookup(writableScope)
-
-            createEnumSyntheticMethods(classObject, this.getDefaultType())
-
-            classObject
         }
         else null
     }
 
-    private fun createEnumSyntheticMethods(classObject: MutableClassDescriptor, enumType: JetType) {
-        val valuesReturnType = KotlinBuiltIns.getInstance().getArrayType(enumType)
-        val valuesMethod = DescriptorFactory.createEnumClassObjectValuesMethod(classObject, valuesReturnType)
-        classObject.getBuilder().addFunctionDescriptor(valuesMethod)
-
-        val valueOfMethod = DescriptorFactory.createEnumClassObjectValueOfMethod(classObject, enumType)
-        classObject.getBuilder().addFunctionDescriptor(valueOfMethod)
-    }
-
     override fun getCorrespondingPackageFragment() =
             c.packageFragmentProvider.getPackageFragment(fqName) as? JavaClassStaticsPackageFragmentDescriptor
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt

@@ -43,12 +43,11 @@ import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaMemberScope.
 public class LazyJavaClassMemberScope(
         c: LazyJavaResolverContextWithTypes,
         containingDeclaration: ClassDescriptor,
-        private val jClass: JavaClass,
+        private val jClass: JavaClass
-        private val enumClassObject: Boolean = false
 ) : LazyJavaMemberScope(c, containingDeclaration) {
 
     override fun computeMemberIndex(): MemberIndex {
-        return object : ClassMemberIndex(jClass, { !enumClassObject && !it.isStatic() }) {
+        return object : ClassMemberIndex(jClass, { !it.isStatic() }) {
             // For SAM-constructors
             override fun getAllMethodNames(): Collection<Name> = super.getAllMethodNames() + getAllClassNames()
         }
@@ -239,7 +238,7 @@ public class LazyJavaClassMemberScope(
         }
     }
 
-    override fun getClassifier(name: Name): ClassifierDescriptor? = if (enumClassObject) null else nestedClasses(name)
+    override fun getClassifier(name: Name): ClassifierDescriptor? = nestedClasses(name)
     override fun getAllClassNames(): Collection<Name> = nestedClassIndex().keySet() + enumEntryIndex().keySet()
 
     // TODO

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt

@@ -233,9 +233,7 @@ public abstract class LazyJavaMemberScope(
 
         val field = memberIndex().findFieldByName(name)
         if (field != null && !field.isEnumEntry()) {
-            if (!DescriptorUtils.isEnumClassObject(_containingDeclaration)) {
+            properties.add(resolveProperty(field))
-                properties.add(resolveProperty(field))
-            }
         }
 
         computeNonDeclaredProperties(name, properties)

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/EnumClassObjectDescriptor.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2010-2014 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.descriptors.impl
+
+import org.jetbrains.jet.storage.StorageManager
+import org.jetbrains.jet.lang.descriptors.*
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations
+import org.jetbrains.jet.lang.resolve.name.SpecialNames
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler
+import org.jetbrains.jet.lang.resolve.DescriptorUtils
+import org.jetbrains.jet.lang.resolve.DescriptorFactory
+import org.jetbrains.jet.lang.types.TypeConstructor
+import org.jetbrains.jet.lang.types.TypeConstructorImpl
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
+import org.jetbrains.jet.lang.resolve.OverridingUtil
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope.LockLevel
+import org.jetbrains.jet.lang.types.DelegatingType
+
+public class EnumClassObjectDescriptor(
+        storageManager: StorageManager,
+        enumClass: ClassDescriptor
+) : ClassDescriptorBase(storageManager, enumClass, SpecialNames.getClassObjectName(enumClass.getName())) {
+    private val primaryConstructor = DescriptorFactory.createPrimaryConstructorForObject(this)
+
+    ;{
+        primaryConstructor.setReturnType(object : DelegatingType() {
+            override fun getDelegate() = getDefaultType()
+        })
+    }
+
+    private val _typeConstructor = TypeConstructorImpl.createForClass(this, getAnnotations(), true, getName().asString(),
+                                                                      listOf(), listOf(KotlinBuiltIns.getInstance().getAnyType()))
+
+    private val scope = WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "MemberLookup")
+
+    ;{
+        val enumType = (getContainingDeclaration() as ClassDescriptor).getDefaultType()
+        val enumArrayType = KotlinBuiltIns.getInstance().getArrayType(enumType)
+        scope.addFunctionDescriptor(DescriptorFactory.createEnumClassObjectValuesMethod(this, enumArrayType))
+        scope.addFunctionDescriptor(DescriptorFactory.createEnumClassObjectValueOfMethod(this, enumType))
+
+        val sink = object : OverridingUtil.DescriptorSink {
+            override fun addToScope(fakeOverride: CallableMemberDescriptor) {
+                OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null)
+                scope.addFunctionDescriptor(fakeOverride as SimpleFunctionDescriptor)
+            }
+
+            override fun conflict(fromSuper: CallableMemberDescriptor, fromCurrent: CallableMemberDescriptor) {
+                throw IllegalStateException("Conflict on enum class object override: $fromSuper vs $fromCurrent")
+            }
+        }
+
+        val superScope = KotlinBuiltIns.getInstance().getAnyType().getMemberScope()
+
+        for (descriptor in superScope.getAllDescriptors()) {
+            if (descriptor is FunctionDescriptor) {
+                val name = descriptor.getName()
+                OverridingUtil.generateOverridesInFunctionGroup(name, superScope.getFunctions(name), setOf(), this, sink)
+            }
+        }
+
+        scope.changeLockLevel(LockLevel.READING)
+    }
+
+    override fun getScopeForMemberLookup(): JetScope = scope
+
+    override fun getClassObjectDescriptor(): ClassDescriptor? = null
+
+    override fun getConstructors(): List<ConstructorDescriptor> = listOf(primaryConstructor)
+
+    override fun getUnsubstitutedPrimaryConstructor(): ConstructorDescriptor = primaryConstructor
+
+    override fun getTypeConstructor(): TypeConstructor = _typeConstructor
+
+    override fun getKind(): ClassKind = ClassKind.CLASS_OBJECT
+
+    override fun getModality(): Modality = Modality.FINAL
+
+    override fun getVisibility(): Visibility = DescriptorUtils.getSyntheticClassObjectVisibility()
+
+    override fun isInner(): Boolean = false
+
+    override fun getAnnotations(): Annotations = Annotations.EMPTY
+}

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java

@@ -30,10 +30,9 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.AbstractClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.EnumClassObjectDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.EnumEntrySyntheticClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorFactory;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -41,7 +40,6 @@ import org.jetbrains.jet.lang.types.AbstractClassTypeConstructor;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
 import org.jetbrains.jet.storage.NotNullLazyValue;
 import org.jetbrains.jet.storage.NullableLazyValue;
@@ -234,7 +232,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         }
 
         if (getKind() == ClassKind.ENUM_CLASS) {
-            return createEnumClassObject();
+            return new EnumClassObjectDescriptor(context.getStorageManager(), this);
         }
 
         if (getKind() == ClassKind.OBJECT) {
@@ -249,49 +247,6 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         return ContextPackage.deserializeClass(context, classId.createNestedClassId(getClassObjectName(getName())));
     }
 
-    @NotNull
-    private ClassDescriptorWithResolutionScopes createEnumClassObject() {
-        final MutableClassDescriptor classObject = new MutableClassDescriptor(this, getScopeForMemberLookup(), ClassKind.CLASS_OBJECT,
-                                                                              false, getClassObjectName(getName()));
-        JetType supertype = KotlinBuiltIns.getInstance().getAnyType();
-        classObject.setSupertypes(Collections.singleton(supertype));
-        classObject.setModality(Modality.FINAL);
-        classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility());
-        classObject.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
-        classObject.setPrimaryConstructor(DescriptorFactory.createPrimaryConstructorForObject(classObject));
-        classObject.createTypeConstructor();
-
-        JetType enumType = getDefaultType();
-        JetType enumArrayType = KotlinBuiltIns.getInstance().getArrayType(enumType);
-        classObject.getBuilder().addFunctionDescriptor(DescriptorFactory.createEnumClassObjectValuesMethod(classObject, enumArrayType));
-        classObject.getBuilder().addFunctionDescriptor(DescriptorFactory.createEnumClassObjectValueOfMethod(classObject, enumType));
-
-        OverridingUtil.DescriptorSink sink = new OverridingUtil.DescriptorSink() {
-            @Override
-            public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
-                OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null);
-                classObject.getBuilder().addFunctionDescriptor((SimpleFunctionDescriptor) fakeOverride);
-            }
-
-            @Override
-            public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) {
-                throw new IllegalStateException("Conflict on enum class object override: " + fromSuper + " vs " + fromCurrent);
-            }
-        };
-
-        JetScope superScope = supertype.getMemberScope();
-
-        for (DeclarationDescriptor descriptor : superScope.getAllDescriptors()) {
-            if (descriptor instanceof FunctionDescriptor) {
-                Name name = descriptor.getName();
-                OverridingUtil.generateOverridesInFunctionGroup(name, superScope.getFunctions(name),
-                                                                Collections.<FunctionDescriptor>emptySet(), classObject, sink);
-            }
-        }
-
-        return classObject;
-    }
-
     @Nullable
     @Override
     public ClassDescriptor getClassObjectDescriptor() {