Minor, add "storageManager" property to context for convenience

core/serialization/src/org/jetbrains/jet/descriptors/serialization/DeserializedType.kt

@@ -29,13 +29,13 @@ class DeserializedType(
 ) : AbstractJetType(), LazyType {
     private val typeDeserializer = c.typeDeserializer
 
-    private val constructor = c.components.storageManager.createLazyValue {
+    private val constructor = c.storageManager.createLazyValue {
         typeDeserializer.typeConstructor(typeProto)
     }
 
     private val arguments = typeDeserializer.typeArguments(typeProto.getArgumentList())
 
-    private val memberScope = c.components.storageManager.createLazyValue {
+    private val memberScope = c.storageManager.createLazyValue {
         computeMemberScope()
     }
 

core/serialization/src/org/jetbrains/jet/descriptors/serialization/MemberDeserializer.kt

@@ -112,7 +112,7 @@ public class MemberDeserializer(private val c: DeserializationContext) {
 
         if (Flags.HAS_CONSTANT.get(flags)) {
             property.setCompileTimeInitializer(
-                c.components.storageManager.createNullableLazyValue {
+                c.storageManager.createNullableLazyValue {
                     val container = c.containingDeclaration.asClassOrPackage()
                     c.components.constantLoader.loadPropertyConstant(container, proto, c.nameResolver, AnnotatedCallableKind.PROPERTY)
                 }
@@ -164,7 +164,7 @@ public class MemberDeserializer(private val c: DeserializationContext) {
         if (!Flags.HAS_ANNOTATIONS.get(flags)) {
             return Annotations.EMPTY
         }
-        return DeserializedAnnotations(c.components.storageManager) {
+        return DeserializedAnnotations(c.storageManager) {
             c.components.annotationLoader.loadCallableAnnotations(
                     c.containingDeclaration.asClassOrPackage(), proto, c.nameResolver, kind
             )
@@ -196,7 +196,7 @@ public class MemberDeserializer(private val c: DeserializationContext) {
         if (!Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags())) {
             return Annotations.EMPTY
         }
-        return DeserializedAnnotations(c.components.storageManager) {
+        return DeserializedAnnotations(c.storageManager) {
             c.components.annotationLoader.loadValueParameterAnnotations(classOrPackage, callable, c.nameResolver, kind, valueParameter)
         }
     }

core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.kt

@@ -31,11 +31,11 @@ public class TypeDeserializer(
         private val typeParameterProtos: List<ProtoBuf.TypeParameter>,
         private val debugName: String
 ) {
-    private val classDescriptors: (Int) -> ClassDescriptor? = c.components.storageManager.createMemoizedFunctionWithNullableValues {
+    private val classDescriptors: (Int) -> ClassDescriptor? = c.storageManager.createMemoizedFunctionWithNullableValues {
         fqNameIndex -> computeClassDescriptor(fqNameIndex)
     }
 
-    private val typeParameterDescriptors = c.components.storageManager.createLazyValue {
+    private val typeParameterDescriptors = c.storageManager.createLazyValue {
         if (typeParameterProtos.isEmpty()) {
             mapOf<Int, TypeParameterDescriptor>()
         }

core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt

@@ -53,6 +53,8 @@ public class DeserializationContext(
 
     val memberDeserializer = MemberDeserializer(this)
 
+    val storageManager: StorageManager get() = components.storageManager
+
     fun childContext(
             descriptor: DeclarationDescriptor,
             typeParameterProtos: List<ProtoBuf.TypeParameter>,

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

@@ -43,7 +43,7 @@ public class DeserializedClassDescriptor(
         private val classProto: ProtoBuf.Class,
         nameResolver: NameResolver
 ) : ClassDescriptor, AbstractClassDescriptor(
-        outerContext.components.storageManager,
+        outerContext.storageManager,
         nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName()
 ) {
     private val modality = serialization.modality(Flags.MODALITY.get(classProto.getFlags()))
@@ -62,14 +62,14 @@ public class DeserializedClassDescriptor(
     private val enumEntries = EnumEntryClassDescriptors()
 
     private val containingDeclaration = outerContext.containingDeclaration
-    private val primaryConstructor = c.components.storageManager.createNullableLazyValue { computePrimaryConstructor() }
+    private val primaryConstructor = c.storageManager.createNullableLazyValue { computePrimaryConstructor() }
-    private val classObjectDescriptor = c.components.storageManager.createNullableLazyValue { computeClassObjectDescriptor() }
+    private val classObjectDescriptor = c.storageManager.createNullableLazyValue { computeClassObjectDescriptor() }
 
     private val annotations =
             if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) {
                 Annotations.EMPTY
             }
-            else DeserializedAnnotations(c.components.storageManager) {
+            else DeserializedAnnotations(c.storageManager) {
                 c.components.annotationLoader.loadClassAnnotations(this, classProto)
             }
 
@@ -170,7 +170,7 @@ public class DeserializedClassDescriptor(
 
     private inner class DeserializedClassMemberScope : DeserializedMemberScope(c, classProto.getMemberList()) {
         private val classDescriptor: DeserializedClassDescriptor get() = this@DeserializedClassDescriptor
-        private val allDescriptors = c.components.storageManager.createLazyValue {
+        private val allDescriptors = c.storageManager.createLazyValue {
             computeDescriptors(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER)
         }
 
@@ -241,7 +241,7 @@ public class DeserializedClassDescriptor(
     private inner class NestedClassDescriptors {
         private val nestedClassNames = nestedClassNames()
 
-        val findNestedClass = c.components.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
+        val findNestedClass = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
             name ->
             if (name in nestedClassNames) {
                 c.components.deserializeClass(classId.createNestedClassId(name))
@@ -279,17 +279,17 @@ public class DeserializedClassDescriptor(
             return result
         }
 
-        val findEnumEntry = c.components.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
+        val findEnumEntry = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
             name ->
             if (name in enumEntryNames) {
                 EnumEntrySyntheticClassDescriptor.create(
-                        c.components.storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, SourceElement.NO_SOURCE
+                        c.storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, SourceElement.NO_SOURCE
                 )
             }
             else null
         }
 
-        private val enumMemberNames = c.components.storageManager.createLazyValue { computeEnumMemberNames() }
+        private val enumMemberNames = c.storageManager.createLazyValue { computeEnumMemberNames() }
 
         private fun computeEnumMemberNames(): Collection<Name> {
             // NOTE: order of enum entry members should be irrelevant

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.kt

@@ -45,11 +45,11 @@ public abstract class DeserializedMemberScope protected(
     }
 
     private val membersProtos =
-            c.components.storageManager.createLazyValue { groupByKey(filteredMemberProtos(membersList)) }
+            c.storageManager.createLazyValue { groupByKey(filteredMemberProtos(membersList)) }
     private val functions =
-            c.components.storageManager.createMemoizedFunction<Name, Collection<FunctionDescriptor>> { computeFunctions(it) }
+            c.storageManager.createMemoizedFunction<Name, Collection<FunctionDescriptor>> { computeFunctions(it) }
     private val properties =
-            c.components.storageManager.createMemoizedFunction<Name, Collection<VariableDescriptor>> { computeProperties(it) }
+            c.storageManager.createMemoizedFunction<Name, Collection<VariableDescriptor>> { computeProperties(it) }
 
     protected open fun filteredMemberProtos(allMemberProtos: Collection<ProtoBuf.Callable>): Collection<ProtoBuf.Callable> = allMemberProtos
 

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.kt

@@ -36,7 +36,7 @@ public open class DeserializedPackageMemberScope(
 ) : DeserializedMemberScope(components.createContext(packageDescriptor, nameResolver), proto.getMemberList()) {
 
     private val packageFqName = packageDescriptor.fqName
-    private val classNames = c.components.storageManager.createLazyValue(classNames)
+    private val classNames = c.storageManager.createLazyValue(classNames)
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
             = computeDescriptors(kindFilter, nameFilter)

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

@@ -35,7 +35,7 @@ public class DeserializedTypeParameterDescriptor extends AbstractLazyTypeParamet
     private final TypeDeserializer typeDeserializer;
 
     public DeserializedTypeParameterDescriptor(@NotNull DeserializationContext c, @NotNull ProtoBuf.TypeParameter proto, int index) {
-        super(c.getComponents().getStorageManager(),
+        super(c.getStorageManager(),
               c.getContainingDeclaration(),
               c.getNameResolver().getName(proto.getName()),
               SerializationPackage.variance(proto.getVariance()),