diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.kt b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.kt
index b882c1a1c61..2da98cd04e2 100644
--- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.kt
+++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.kt
@@ -46,7 +46,7 @@ public fun DeserializedClassDescriptor(globalContext: DeserializationGlobalConte
         = DeserializedClassDescriptor(globalContext.withNameResolver(classData.getNameResolver()), classData.getClassProto())
 
 public class DeserializedClassDescriptor(outerContext: DeserializationContext, private val classProto: ProtoBuf.Class)
-  : AbstractClassDescriptor(outerContext.storageManager, outerContext.nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName()), ClassDescriptor {
+: AbstractClassDescriptor(outerContext.storageManager, outerContext.nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName()), ClassDescriptor {
 
     private val modality = serialization.modality(Flags.MODALITY.get(classProto.getFlags()))
     private val visibility = serialization.visibility(Flags.VISIBILITY.get(classProto.getFlags()))
@@ -61,6 +61,7 @@ public class DeserializedClassDescriptor(outerContext: DeserializationContext, p
     private val typeConstructor = DeserializedClassTypeConstructor(typeParameters)
     private val memberScope = DeserializedClassMemberScope()
     private val nestedClasses = NestedClassDescriptors()
+    private val enumEntries = EnumEntryClassDescriptors()
 
     private val containingDeclaration = outerContext.storageManager.createLazyValue { computeContainingDeclaration() }
     private val annotations = context.storageManager.createLazyValue { computeAnnotations() }
@@ -236,32 +237,23 @@ public class DeserializedClassDescriptor(outerContext: DeserializationContext, p
 
         override fun getImplicitReceiver() = classDescriptor.getThisAsReceiverParameter()
 
-        override fun getClassDescriptor(name: Name): ClassifierDescriptor? = classDescriptor.nestedClasses.findClass(name)
+        override fun getClassDescriptor(name: Name): ClassifierDescriptor? =
+                classDescriptor.enumEntries.findEnumEntry(name) ?: classDescriptor.nestedClasses.findNestedClass(name)
 
         override fun addClassDescriptors(result: MutableCollection<DeclarationDescriptor>, nameFilter: (Name) -> Boolean) {
-            result.addAll(classDescriptor.nestedClasses.getAllDescriptors())
+            result.addAll(classDescriptor.nestedClasses.all() + classDescriptor.enumEntries.all())
         }
     }
 
     private inner class NestedClassDescriptors {
         private val nestedClassNames = nestedClassNames()
-        private val enumEntryNames = enumEntryNames()
 
-        val findClass: MemoizedFunctionToNullable<Name, ClassDescriptor> = run {
-            val storageManager = context.storageManager
-            val enumMemberNames = storageManager.createLazyValue { computeEnumMemberNames() }
-
-            storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> { name ->
-                if (enumEntryNames.contains(name)) {
-                    EnumEntrySyntheticClassDescriptor.create(storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, SourceElement.NO_SOURCE)
-                }
-                else if (nestedClassNames.contains(name)) {
-                    context.deserializeClass(classId.createNestedClassId(name))
-                }
-                else {
-                    null
-                }
+        val findNestedClass = context.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
+            name ->
+            if (nestedClassNames.contains(name)) {
+                context.deserializeClass(classId.createNestedClassId(name))
             }
+            else null
         }
 
         private fun nestedClassNames(): Set<Name> {
@@ -273,6 +265,16 @@ public class DeserializedClassDescriptor(outerContext: DeserializationContext, p
             return result
         }
 
+        fun all(): Collection<ClassDescriptor> {
+            val result = ArrayList<ClassDescriptor>(nestedClassNames.size())
+            nestedClassNames.forEach { name -> result.addIfNotNull(findNestedClass(name)) }
+            return result
+        }
+    }
+
+    private inner class EnumEntryClassDescriptors {
+        private val enumEntryNames = enumEntryNames()
+
         private fun enumEntryNames(): Set<Name> {
             if (getKind() != ClassKind.ENUM_CLASS) return setOf()
 
@@ -284,6 +286,18 @@ public class DeserializedClassDescriptor(outerContext: DeserializationContext, p
             return result
         }
 
+        val findEnumEntry = context.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
+            name ->
+            if (name in enumEntryNames) {
+                EnumEntrySyntheticClassDescriptor.create(
+                        context.storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, SourceElement.NO_SOURCE
+                )
+            }
+            else null
+        }
+
+        private val enumMemberNames = context.storageManager.createLazyValue { computeEnumMemberNames() }
+
         private fun computeEnumMemberNames(): Collection<Name> {
             // NOTE: order of enum entry members should be irrelevant
             // because enum entries are effectively invisible to user (as classes)
@@ -301,14 +315,9 @@ public class DeserializedClassDescriptor(outerContext: DeserializationContext, p
             return classProto.getMemberList().mapTo(result) { nameResolver.getName(it.getName()) }
         }
 
-        public fun getAllDescriptors(): Collection<ClassDescriptor> {
-            val result = ArrayList<ClassDescriptor>(nestedClassNames.size() + enumEntryNames.size())
-            for (name in nestedClassNames) {
-                result.addIfNotNull(findClass(name))
-            }
-            for (name in enumEntryNames) {
-                result.addIfNotNull(findClass(name))
-            }
+        fun all(): Collection<ClassDescriptor> {
+            val result = ArrayList<ClassDescriptor>(enumEntryNames.size())
+            enumEntryNames.forEach { name -> result.addIfNotNull(findEnumEntry(name)) }
             return result
         }
     }