Optimize LazyScopeAdapter internals

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -440,9 +440,9 @@ class TypeResolver(
     private fun getScopeForTypeParameter(c: TypeResolutionContext, typeParameterDescriptor: TypeParameterDescriptor): MemberScope {
         return when {
             c.checkBounds -> TypeIntersector.getUpperBoundsAsType(typeParameterDescriptor).memberScope
-            else -> LazyScopeAdapter(LockBasedStorageManager.NO_LOCKS.createLazyValue {
+            else -> LazyScopeAdapter {
                 TypeIntersector.getUpperBoundsAsType(typeParameterDescriptor).memberScope
-            })
+            }
         }
     }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/WrappedDescriptors.kt

@@ -281,12 +281,12 @@ open class WrappedTypeParameterDescriptor(
     private val _defaultType: SimpleType by lazy {
         KotlinTypeFactory.simpleTypeWithNonTrivialMemberScope(
             Annotations.EMPTY, typeConstructor, emptyList(), false,
-            LazyScopeAdapter(LockBasedStorageManager.NO_LOCKS.createLazyValue {
+            LazyScopeAdapter {
                 TypeIntersectionScope.create(
                     "Scope for type parameter " + name.asString(),
                     upperBounds
                 )
-            })
+            }
         )
     }
 

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java

@@ -72,14 +72,14 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
                 return KotlinTypeFactory.simpleTypeWithNonTrivialMemberScope(
                         Annotations.Companion.getEMPTY(),
                         getTypeConstructor(), Collections.<TypeProjection>emptyList(), false,
-                        new LazyScopeAdapter(storageManager.createLazyValue(
+                        new LazyScopeAdapter(
                                 new Function0<MemberScope>() {
                                     @Override
                                     public MemberScope invoke() {
                                         return TypeIntersectionScope.create("Scope for type parameter " + name.asString(), getUpperBounds());
                                     }
                                 }
-                        ))
+                        )
                 );
             }
         });

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyPackageViewDescriptorImpl.kt

@@ -37,16 +37,15 @@ class LazyPackageViewDescriptorImpl(
         module.packageFragmentProvider.getPackageFragments(fqName)
     }
 
-    override val memberScope: MemberScope = LazyScopeAdapter(storageManager.createLazyValue {
+    override val memberScope: MemberScope = LazyScopeAdapter(storageManager) {
         if (fragments.isEmpty()) {
             MemberScope.Empty
-        }
-        else {
+        } else {
             // Packages from SubpackagesScope are got via getContributedDescriptors(DescriptorKindFilter.PACKAGES, MemberScope.ALL_NAME_FILTER)
             val scopes = fragments.map { it.getMemberScope() } + SubpackagesScope(module, fqName)
-            ChainedMemberScope("package view scope for $fqName in ${module.name}", scopes)
+            ChainedMemberScope.create("package view scope for $fqName in ${module.name}", scopes)
         }
-    })
+    }
 
     override fun getContainingDeclaration(): PackageViewDescriptor? {
         return if (fqName.isRoot) null else module.getPackage(fqName.parent())

core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/LazyScopeAdapter.kt

@@ -16,9 +16,20 @@
 
 package org.jetbrains.kotlin.resolve.scopes
 
-import org.jetbrains.kotlin.storage.NotNullLazyValue
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
+
+class LazyScopeAdapter @JvmOverloads constructor(
+    storageManager: StorageManager = LockBasedStorageManager.NO_LOCKS,
+    getScope: () -> MemberScope
+) : AbstractScopeAdapter() {
+
+    private val lazyScope = storageManager.createLazyValue{
+        getScope().let {
+            if (it is AbstractScopeAdapter) it.getActualScope() else it
+        }
+    }
 
-class LazyScopeAdapter(private val scope: NotNullLazyValue<MemberScope>) : AbstractScopeAdapter() {
     override val workerScope: MemberScope
-        get() = scope()
+        get() = lazyScope()
 }