Deserializers use storage manager

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.descriptors.serialization;
 
+import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
@@ -23,11 +24,12 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClass
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullable;
-import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullableImpl;
 import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import static org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager.ReferenceKind.STRONG;
+
 public abstract class AbstractClassResolver implements ClassResolver {
 
     private final NestedClassResolver nestedClassResolver;
@@ -51,9 +53,9 @@ public abstract class AbstractClassResolver implements ClassResolver {
             }
         };
 
-        this.findClass = new MemoizedFunctionToNullableImpl<ClassId, ClassDescriptor>() {
+        this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function<ClassId, ClassDescriptor>() {
             @Override
-            protected ClassDescriptor doCompute(ClassId classId) {
+            public ClassDescriptor fun(ClassId classId) {
                 ClassData classData = getClassData(classId);
                 if (classData == null) {
                     return null;
@@ -73,7 +75,7 @@ public abstract class AbstractClassResolver implements ClassResolver {
                 classDescriptorCreated(classDescriptor);
                 return classDescriptor;
             }
-        };
+        }, STRONG);
     }
 
     @Nullable

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java

@@ -22,42 +22,44 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeseria
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.Modality;
-import org.jetbrains.jet.lang.descriptors.Visibility;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
-import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
 import org.jetbrains.jet.lang.types.Variance;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
-import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.*;
+import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable;
+import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter;
 import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE;
 
 public class DescriptorDeserializer {
 
     @NotNull
     public static DescriptorDeserializer create(
+            @NotNull StorageManager storageManager,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull NameResolver nameResolver,
             @NotNull ClassResolver classResolver,
             @NotNull AnnotationDeserializer annotationDeserializer
     ) {
-        return new DescriptorDeserializer(
+        return new DescriptorDeserializer(storageManager,
-                new TypeDeserializer(null, nameResolver, classResolver, "Deserializer for " + containingDeclaration, NONE),
+                new TypeDeserializer(storageManager, null, nameResolver, classResolver, "Deserializer for " + containingDeclaration, NONE),
                 containingDeclaration, nameResolver, annotationDeserializer);
     }
 
     @NotNull
     public static DescriptorDeserializer create(
+            @NotNull StorageManager storageManager,
             @NotNull TypeDeserializer typeDeserializer,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull NameResolver nameResolver,
             @NotNull AnnotationDeserializer annotationDeserializer
     ) {
-        return new DescriptorDeserializer(typeDeserializer, containingDeclaration, nameResolver, annotationDeserializer);
+        return new DescriptorDeserializer(storageManager, typeDeserializer, containingDeclaration, nameResolver, annotationDeserializer);
     }
 
     private final DeclarationDescriptor containingDeclaration;
@@ -65,14 +67,16 @@ public class DescriptorDeserializer {
     private final TypeDeserializer typeDeserializer;
     private final AnnotationDeserializer annotationDeserializer;
 
-    private final StorageManager storageManager = new LockBasedStorageManager();
+    private final StorageManager storageManager;
 
     private DescriptorDeserializer(
+            @NotNull StorageManager storageManager,
             @NotNull TypeDeserializer typeDeserializer,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull NameResolver nameResolver,
             @NotNull AnnotationDeserializer annotationDeserializer
     ) {
+        this.storageManager = storageManager;
         this.typeDeserializer = typeDeserializer;
         this.containingDeclaration = containingDeclaration;
         this.nameResolver = nameResolver;
@@ -96,6 +100,7 @@ public class DescriptorDeserializer {
             @NotNull final List<TypeParameterDescriptor> typeParameters
     ) {
         TypeDeserializer childTypeDeserializer = new TypeDeserializer(
+                storageManager,
                 typeDeserializer, "Child deserializer for " + descriptor,
                 new TypeDeserializer.TypeParameterResolver() {
                     @NotNull
@@ -106,7 +111,7 @@ public class DescriptorDeserializer {
                         return descriptors;
                     }
                 });
-        return create(childTypeDeserializer, descriptor, nameResolver, annotationDeserializer);
+        return create(storageManager, childTypeDeserializer, descriptor, nameResolver, annotationDeserializer);
     }
 
     @NotNull

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.descriptors.serialization;
 
+import com.intellij.util.Function;
 import gnu.trove.TIntObjectHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -33,6 +34,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager.ReferenceKind.STRONG;
+
 public class TypeDeserializer {
 
     public interface TypeParameterResolver {
@@ -60,14 +63,16 @@ public class TypeDeserializer {
     private final String debugName;
 
     public TypeDeserializer(
+            @NotNull StorageManager storageManager,
             @NotNull TypeDeserializer parent,
             @NotNull String debugName,
             @NotNull TypeParameterResolver typeParameterResolver
     ) {
-        this(parent, parent.nameResolver, parent.classResolver, debugName, typeParameterResolver);
+        this(storageManager, parent, parent.nameResolver, parent.classResolver, debugName, typeParameterResolver);
     }
 
     public TypeDeserializer(
+            @NotNull StorageManager storageManager,
             @Nullable TypeDeserializer parent,
             @NotNull NameResolver nameResolver,
             @NotNull ClassResolver classResolver,
@@ -83,12 +88,12 @@ public class TypeDeserializer {
             typeParameterDescriptors.put(typeParameterDescriptor.getProtoId(), typeParameterDescriptor);
         }
 
-        this.classDescriptors = new MemoizedFunctionToNullableImpl<Integer, ClassDescriptor>() {
+        this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function<Integer, ClassDescriptor>() {
             @Override
-            protected ClassDescriptor doCompute(@NotNull Integer fqNameIndex) {
+            public ClassDescriptor fun(Integer fqNameIndex) {
                 return computeClassDescriptor(fqNameIndex);
             }
-        };
+        }, STRONG);
     }
 
     @NotNull

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java

@@ -81,9 +81,10 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
         this.classProto = classProto;
         this.name = nameResolver.getName(classProto.getName());
 
-        TypeDeserializer notNullTypeDeserializer = new TypeDeserializer(outerTypeDeserializer, nameResolver, classResolver,
+        TypeDeserializer notNullTypeDeserializer = new TypeDeserializer(storageManager, outerTypeDeserializer, nameResolver, classResolver,
                                                                         "Deserializer for class " + name, NONE);
-        DescriptorDeserializer outerDeserializer = DescriptorDeserializer.create(notNullTypeDeserializer, this, nameResolver, annotationResolver);
+        DescriptorDeserializer outerDeserializer = DescriptorDeserializer.create(storageManager, notNullTypeDeserializer,
+                                                                                 this, nameResolver, annotationResolver);
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(classProto.getTypeParametersCount());
         this.deserializer = outerDeserializer.createChildDeserializer(this, classProto.getTypeParametersList(), typeParameters);
         this.typeDeserializer = deserializer.getTypeDeserializer();

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java

@@ -96,7 +96,7 @@ class BuiltinsNamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl {
             members = new DeserializedPackageMemberScope(
                     storageManager,
                     this,
-                    DescriptorDeserializer.create(this, nameResolver, classResolver, AnnotationDeserializer.UNSUPPORTED),
+                    DescriptorDeserializer.create(storageManager, this, nameResolver, classResolver, AnnotationDeserializer.UNSUPPORTED),
                     loadCallables(), classResolver
             ) {
                 private final NotNullLazyValue<Collection<Name>> classNames = new NotNullLazyValueImpl<Collection<Name>>() {

compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java

@@ -224,7 +224,8 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
         }
 
         DescriptorDeserializer deserializer =
-                DescriptorDeserializer.create(namespace, new NameResolver(simpleNames, qualifiedNames), classResolver, UNSUPPORTED);
+                DescriptorDeserializer.create(new LockBasedStorageManager(), namespace, new NameResolver(simpleNames, qualifiedNames),
+                                              classResolver, UNSUPPORTED);
         for (ProtoBuf.Callable proto : callableProtos) {
             CallableMemberDescriptor descriptor = deserializer.loadCallable(proto);
             if (descriptor instanceof FunctionDescriptor) {

compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltinsDeserializationTest.java

@@ -198,7 +198,7 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
     ) {
         DescriptorDeserializer descriptorDeserializer;
         descriptorDeserializer =
-                DescriptorDeserializer.create(actualNamespace, nameResolver, classResolver, AnnotationDeserializer.UNSUPPORTED);
+                DescriptorDeserializer.create(new LockBasedStorageManager(), actualNamespace, nameResolver, classResolver, AnnotationDeserializer.UNSUPPORTED);
         for (ProtoBuf.Callable callableProto : callableProtos) {
             CallableMemberDescriptor callableMemberDescriptor = descriptorDeserializer.loadCallable(callableProto);
             if (callableMemberDescriptor instanceof PropertyDescriptor) {