Same storage manager used by lazy resolve session in AnalyzerFacadeForJVM and the rest of the components

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -50,7 +50,7 @@ public class InjectorForJavaDescriptorResolver {
     
     private final Project project;
     private final BindingTrace bindingTrace;
-    private final LockBasedStorageManager storageManager;
+    private final LockBasedStorageManager lockBasedStorageManager;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
@@ -81,7 +81,7 @@ public class InjectorForJavaDescriptorResolver {
     ) {
         this.project = project;
         this.bindingTrace = bindingTrace;
-        this.storageManager = new LockBasedStorageManager();
+        this.lockBasedStorageManager = new LockBasedStorageManager();
         this.javaClassFinder = new JavaClassFinderImpl();
         this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
@@ -96,7 +96,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaAnnotationArgumentResolver = new JavaAnnotationArgumentResolver();
         this.javaClassResolver = new JavaClassResolver();
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(storageManager);
+        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(getLockBasedStorageManager());
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaTypeParameterResolver = new JavaTypeParameterResolver();
         this.javaTypeTransformer = new JavaTypeTransformer();
@@ -129,7 +129,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaDescriptorResolver.setModule(module);
         this.javaDescriptorResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
         this.javaDescriptorResolver.setSignatureChecker(psiBasedMethodSignatureChecker);
-        this.javaDescriptorResolver.setStorageManager(storageManager);
+        this.javaDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache);
         javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
@@ -162,7 +162,7 @@ public class InjectorForJavaDescriptorResolver {
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider);
-        deserializedDescriptorResolver.setStorageManager(storageManager);
+        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
         annotationDescriptorDeserializer.setJavaDescriptorResolver(javaDescriptorResolver);
@@ -211,6 +211,10 @@ public class InjectorForJavaDescriptorResolver {
     public void destroy() {
     }
     
+    public LockBasedStorageManager getLockBasedStorageManager() {
+        return this.lockBasedStorageManager;
+    }
+    
     public JavaClassFinderImpl getJavaClassFinder() {
         return this.javaClassFinder;
     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java

@@ -100,7 +100,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         final JavaClassFinderImpl classFinder = injector.getJavaClassFinder();
 
         // TODO: Replace with stub declaration provider
-        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager();
+        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(injector.getLockBasedStorageManager());
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate<FqName>() {
             @Override
             public boolean apply(FqName fqName) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java

@@ -18,7 +18,9 @@ package org.jetbrains.jet.lang.resolve.lazy.storage;
 
 import com.google.common.collect.ImmutableMap;
 import com.intellij.util.containers.ConcurrentWeakValueHashMap;
+import jet.Function0;
 import jet.Function1;
+import jet.Unit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
@@ -26,23 +28,27 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.Diagnostics;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.*;
-import org.jetbrains.jet.storage.MemoizedFunctionToNotNull;
-import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
 import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import java.util.Collection;
 import java.util.concurrent.locks.Lock;
 
-public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager implements LazyResolveStorageManager {
+public class LockBasedLazyResolveStorageManager implements LazyResolveStorageManager {
+
+    private final LockBasedStorageManager storageManager;
+
+    public LockBasedLazyResolveStorageManager(@NotNull LockBasedStorageManager storageManager) {
+        this.storageManager = storageManager;
+    }
 
     @Override
     @NotNull
     public <K, V> MemoizedFunctionToNotNull<K, V> createWeaklyRetainedMemoizedFunction(
             @NotNull Function1<K, V> compute
     ) {
-        return super.createMemoizedFunction(compute, new ConcurrentWeakValueHashMap<K, Object>());
+        return storageManager.new Internals().createMemoizedFunction(compute, new ConcurrentWeakValueHashMap<K, Object>());
     }
 
     @NotNull
@@ -50,7 +56,7 @@ public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager
     public <K, V> MemoizedFunctionToNullable<K, V> createWeaklyRetainedMemoizedFunctionWithNullableValues(
             @NotNull Function1<K, V> compute
     ) {
-        return super.createMemoizedFunctionWithNullableValues(compute, new ConcurrentWeakValueHashMap<K, Object>());
+        return storageManager.new Internals().createMemoizedFunctionWithNullableValues(compute, new ConcurrentWeakValueHashMap<K, Object>());
     }
 
     @NotNull
@@ -58,7 +64,73 @@ public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager
     public BindingTrace createSafeTrace(@NotNull BindingTrace originalTrace) {
         // It seems safe to have a separate lock for traces:
         // no other locks will be acquired inside the trace operations
-        return new LockProtectedTrace(lock, originalTrace);
+        return new LockProtectedTrace(storageManager.new Internals().getLock(), originalTrace);
+    }
+
+    @NotNull
+    @Override
+    public <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(@NotNull Function1<? super K, ? extends V> compute) {
+        return storageManager.createMemoizedFunction(compute);
+    }
+
+    @NotNull
+    @Override
+    public <K, V> MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues(@NotNull Function1<? super K, ? extends V> compute) {
+        return storageManager.createMemoizedFunctionWithNullableValues(compute);
+    }
+
+    @NotNull
+    @Override
+    public <T> NotNullLazyValue<T> createLazyValue(@NotNull Function0<? extends T> computable) {
+        return storageManager.createLazyValue(computable);
+    }
+
+    @NotNull
+    @Override
+    public <T> NotNullLazyValue<T> createRecursionTolerantLazyValue(
+            @NotNull Function0<? extends T> computable,
+            @NotNull T onRecursiveCall
+    ) {
+        return storageManager.createRecursionTolerantLazyValue(computable, onRecursiveCall);
+    }
+
+    @NotNull
+    @Override
+    public <T> NotNullLazyValue<T> createLazyValueWithPostCompute(
+            @NotNull Function0<? extends T> computable,
+            @Nullable Function1<? super Boolean, ? extends T> onRecursiveCall,
+            @NotNull Function1<? super T, ? extends Unit> postCompute
+    ) {
+        return storageManager.createLazyValueWithPostCompute(computable, onRecursiveCall, postCompute);
+    }
+
+    @NotNull
+    @Override
+    public <T> NullableLazyValue<T> createNullableLazyValue(@NotNull Function0<? extends T> computable) {
+        return storageManager.createNullableLazyValue(computable);
+    }
+
+    @NotNull
+    @Override
+    public <T> NullableLazyValue<T> createRecursionTolerantNullableLazyValue(
+            @NotNull Function0<? extends T> computable,
+            T onRecursiveCall
+    ) {
+        return storageManager.createRecursionTolerantNullableLazyValue(computable, onRecursiveCall);
+    }
+
+    @NotNull
+    @Override
+    public <T> NullableLazyValue<T> createNullableLazyValueWithPostCompute(
+            @NotNull Function0<? extends T> computable,
+            @NotNull Function1<? super T, ? extends Unit> postCompute
+    ) {
+        return storageManager.createNullableLazyValueWithPostCompute(computable, postCompute);
+    }
+
+    @Override
+    public <T> T compute(@NotNull Function0<? extends T> computable) {
+        return storageManager.compute(computable);
     }
 
     private static class LockProtectedContext implements BindingContext {

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageMa
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 
 import java.io.File;
 import java.io.IOException;
@@ -58,7 +59,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
 
         final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
         lazyModule.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
-        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager();
+        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(new LockBasedStorageManager());
         final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule,
                                                                  new FileBasedDeclarationProviderFactory(storageManager, files));
 

core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java

@@ -61,7 +61,7 @@ public class LockBasedStorageManager implements StorageManager {
     }
 
     @NotNull
-    protected  <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(
+    protected <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(
             @NotNull Function1<? super K, ? extends V> compute,
             @NotNull ConcurrentMap<K, Object> map
     ) {
@@ -374,4 +374,29 @@ public class LockBasedStorageManager implements StorageManager {
             return result;
         }
     }
+
+    @Deprecated // Use with care
+    public class Internals {
+        @NotNull
+        public Lock getLock() {
+            return lock;
+        }
+
+        @NotNull
+        public <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(
+                @NotNull Function1<? super K, ? extends V> compute,
+                @NotNull ConcurrentMap<K, Object> map
+        ) {
+            return LockBasedStorageManager.this.createMemoizedFunction(compute, map);
+        }
+
+        @NotNull
+        public <K, V> MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues(
+                @NotNull Function1<? super K, ? extends V> compute,
+                @NotNull ConcurrentMap<K, Object> map
+        ) {
+            return LockBasedStorageManager.this.createMemoizedFunctionWithNullableValues(compute, map);
+        }
+
+    }
 }

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java

@@ -152,7 +152,7 @@ public class GenerateInjectors {
         generator.addParameter(BindingTrace.class);
 
         // Fields
-        generator.addField(false, StorageManager.class, null, new InstantiateType(LockBasedStorageManager.class));
+        generator.addPublicField(LockBasedStorageManager.class);
         generator.addPublicField(JavaClassFinderImpl.class);
         generator.addField(TraceBasedExternalSignatureResolver.class);
         generator.addField(TraceBasedJavaResolverCache.class);

idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -64,6 +64,7 @@ import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex;
 import org.jetbrains.jet.plugin.stubindex.JetTopLevelFunctionsFqnNameIndex;
 import org.jetbrains.jet.plugin.stubindex.JetTopLevelPropertiesFqnNameIndex;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -214,7 +215,7 @@ public class JetSourceNavigationHelper {
         }
 
         Project project = decompiledDeclaration.getProject();
-        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager();
+        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(new LockBasedStorageManager());
         FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(storageManager, getContainingFiles(candidates),
                 new Predicate<FqName>() {
                     @Override

js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java

@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageMa
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.k2js.config.Config;
 
 import java.util.Collection;
@@ -152,7 +153,7 @@ public final class AnalyzerFacadeForJS {
 
     @NotNull
     public static ResolveSession getLazyResolveSession(Collection<JetFile> files, Config config) {
-        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager();
+        LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(new LockBasedStorageManager());
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
                 storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
         ModuleDescriptorImpl module = createJsModule("<lazy module>");