LazyMemberScope refactoring in progress

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.kt

@@ -29,10 +29,10 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProvider
 import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.storage.MemoizedFunctionToNotNull
-import org.jetbrains.jet.storage.NotNullLazyValue
 import org.jetbrains.jet.utils.Printer
 
 import java.util.*
+import org.jetbrains.jet.storage.StorageManager
 import org.jetbrains.jet.utils.toReadOnlyList
 
 public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : DeclarationProvider> protected(
@@ -41,12 +41,10 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
         protected val thisDescriptor: D,
         protected val trace: BindingTrace) : JetScope {
 
-    private val storageManager = resolveSession.getStorageManager()
+    protected val storageManager: StorageManager = resolveSession.getStorageManager()
     private val classDescriptors: MemoizedFunctionToNotNull<Name, List<ClassDescriptor>> = storageManager.createMemoizedFunction { resolveClassDescriptor(it) }
     private val functionDescriptors: MemoizedFunctionToNotNull<Name, Collection<FunctionDescriptor>> = storageManager.createMemoizedFunction { doGetFunctions(it) }
     private val propertyDescriptors: MemoizedFunctionToNotNull<Name, Collection<VariableDescriptor>> = storageManager.createMemoizedFunction { doGetProperties(it) }
-    private val descriptorsFromDeclaredElements: NotNullLazyValue<Collection<DeclarationDescriptor>> = storageManager.createLazyValue { computeDescriptorsFromDeclaredElements() }
-    private val extraDescriptors: NotNullLazyValue<Collection<DeclarationDescriptor>> = storageManager.createLazyValue { computeExtraDescriptors() }
 
     private fun resolveClassDescriptor(name: Name): List<ClassDescriptor> {
         return declarationProvider.getClassOrObjectDeclarations(name).map {
@@ -120,14 +118,8 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
 
     override fun getDeclarationsByLabel(labelName: Name) = setOf<DeclarationDescriptor>()
 
-    override fun getDescriptors(kindFilter: (JetScope.DescriptorKind) -> Boolean,
+    protected fun computeDescriptorsFromDeclaredElements(kindFilter: (JetScope.DescriptorKind) -> Boolean,
-                                nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
+                                                         nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
-        val result = LinkedHashSet(descriptorsFromDeclaredElements())
-        result.addAll(extraDescriptors())
-        return result
-    }
-
-    private fun computeDescriptorsFromDeclaredElements(): Collection<DeclarationDescriptor> {
         val declarations = declarationProvider.getAllDeclarations()
         val result = ArrayList<DeclarationDescriptor>(declarations.size())
         for (declaration in declarations) {
@@ -157,8 +149,6 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
         return result.toReadOnlyList()
     }
 
-    protected abstract fun computeExtraDescriptors(): Collection<DeclarationDescriptor>
-
     override fun getImplicitReceiversHierarchy() = listOf<ReceiverParameterDescriptor>()
 
     // Do not change this, override in concrete subclasses:

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -37,6 +37,7 @@ import java.util.*
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.DELEGATION
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE
 import org.jetbrains.jet.lang.resolve.DelegationResolver.generateDelegatedMembers
+import org.jetbrains.jet.storage.NotNullLazyValue
 
 public open class LazyClassMemberScope(resolveSession: ResolveSession,
                                   declarationProvider: ClassMemberDeclarationProvider,
@@ -44,10 +45,42 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
                                   trace: BindingTrace)
 : AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider>(resolveSession, declarationProvider, thisClass, trace) {
 
+    private val descriptorsFromDeclaredElements = storageManager.createLazyValue<Collection<DeclarationDescriptor>> {
+        computeDescriptorsFromDeclaredElements({true}, {true})
+    }
+    private val extraDescriptors: NotNullLazyValue<Collection<DeclarationDescriptor>> = storageManager.createLazyValue {
+        computeExtraDescriptors()
+    }
+
+    override fun getDescriptors(kindFilter: (JetScope.DescriptorKind) -> Boolean,
+                                nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
+        val result = LinkedHashSet(descriptorsFromDeclaredElements())
+        result.addAll(extraDescriptors())
+        return result
+    }
+
+    protected open fun computeExtraDescriptors(): Collection<DeclarationDescriptor> {
+        val result = ArrayList<DeclarationDescriptor>()
+        for (supertype in thisDescriptor.getTypeConstructor().getSupertypes()) {
+            for (descriptor in supertype.getMemberScope().getDescriptors()) {
+                if (descriptor is FunctionDescriptor) {
+                    result.addAll(getFunctions(descriptor.getName()))
+                }
+                else if (descriptor is PropertyDescriptor) {
+                    result.addAll(getProperties(descriptor.getName()))
+                }
+                // Nothing else is inherited
+            }
+        }
+
+        addDataClassMethods(result)
+
+        result.trimToSize()
+        return result
+    }
+
     private trait MemberExtractor<T : CallableMemberDescriptor> {
-
         public fun extract(extractFrom: JetType, name: Name): Collection<T>
-
     }
 
     private val primaryConstructor: NullableLazyValue<ConstructorDescriptor>
@@ -203,26 +236,6 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
         return generateDelegatedMembers(classOrObject, thisDescriptor, existingDescriptors, trace, lazyMemberExtractor, lazyTypeResolver)
     }
 
-    override fun computeExtraDescriptors(): Collection<DeclarationDescriptor> {
-        val result = ArrayList<DeclarationDescriptor>()
-        for (supertype in thisDescriptor.getTypeConstructor().getSupertypes()) {
-            for (descriptor in supertype.getMemberScope().getDescriptors()) {
-                if (descriptor is FunctionDescriptor) {
-                    result.addAll(getFunctions(descriptor.getName()))
-                }
-                else if (descriptor is PropertyDescriptor) {
-                    result.addAll(getProperties(descriptor.getName()))
-                }
-                // Nothing else is inherited
-            }
-        }
-
-        addDataClassMethods(result)
-
-        result.trimToSize()
-        return result
-    }
-
     private fun addDataClassMethods(result: MutableCollection<DeclarationDescriptor>) {
         if (!KotlinBuiltIns.getInstance().isData(thisDescriptor)) return
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.kt

@@ -21,6 +21,7 @@ import org.jetbrains.jet.lang.psi.JetDeclaration
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider
 import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
 
 public class LazyPackageMemberScope(
         resolveSession: ResolveSession,
@@ -28,6 +29,10 @@ public class LazyPackageMemberScope(
         thisPackage: PackageFragmentDescriptor)
 : AbstractLazyMemberScope<PackageFragmentDescriptor, PackageMemberDeclarationProvider>(resolveSession, declarationProvider, thisPackage, resolveSession.getTrace()) {
 
+    override fun getDescriptors(kindFilter: (JetScope.DescriptorKind) -> Boolean, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
+        return computeDescriptorsFromDeclaredElements(kindFilter, nameFilter)
+    }
+
     override fun getPackage(name: Name): PackageViewDescriptor? = null
 
     override fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration)
@@ -41,8 +46,6 @@ public class LazyPackageMemberScope(
         // No extra properties
     }
 
-    override fun computeExtraDescriptors(): Collection<DeclarationDescriptor> = listOf()
-
     // Do not add details here, they may compromise the laziness during debugging
     override fun toString() = "lazy scope for package " + thisDescriptor.getName()
 }