From 8f56283771efa9f4ed5cf0feda26573163c894ee Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 17 Jan 2014 12:29:37 +0400 Subject: [PATCH] Same storage manager used by lazy resolve session in AnalyzerFacadeForJVM and the rest of the components --- .../di/InjectorForJavaDescriptorResolver.java | 14 +-- .../resolve/java/AnalyzerFacadeForJVM.java | 2 +- .../LockBasedLazyResolveStorageManager.java | 86 +++++++++++++++++-- ...ractLazyResolveDescriptorRendererTest.java | 3 +- .../jet/storage/LockBasedStorageManager.java | 27 +++++- .../injectors/GenerateInjectors.java | 2 +- .../libraries/JetSourceNavigationHelper.java | 3 +- .../k2js/analyze/AnalyzerFacadeForJS.java | 3 +- 8 files changed, 122 insertions(+), 18 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index 41546a95bda..2405aa5fbf4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/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; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index be028bd25da..9a4e525b20d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/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() { @Override public boolean apply(FqName fqName) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java index 3152c330503..ac1e3794273 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java +++ b/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.MemoizedFunctionToNotNull; -import org.jetbrains.jet.storage.MemoizedFunctionToNullable; +import org.jetbrains.jet.storage.*; 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 MemoizedFunctionToNotNull createWeaklyRetainedMemoizedFunction( @NotNull Function1 compute ) { - return super.createMemoizedFunction(compute, new ConcurrentWeakValueHashMap()); + return storageManager.new Internals().createMemoizedFunction(compute, new ConcurrentWeakValueHashMap()); } @NotNull @@ -50,7 +56,7 @@ public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager public MemoizedFunctionToNullable createWeaklyRetainedMemoizedFunctionWithNullableValues( @NotNull Function1 compute ) { - return super.createMemoizedFunctionWithNullableValues(compute, new ConcurrentWeakValueHashMap()); + return storageManager.new Internals().createMemoizedFunctionWithNullableValues(compute, new ConcurrentWeakValueHashMap()); } @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 MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute) { + return storageManager.createMemoizedFunction(compute); + } + + @NotNull + @Override + public MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute) { + return storageManager.createMemoizedFunctionWithNullableValues(compute); + } + + @NotNull + @Override + public NotNullLazyValue createLazyValue(@NotNull Function0 computable) { + return storageManager.createLazyValue(computable); + } + + @NotNull + @Override + public NotNullLazyValue createRecursionTolerantLazyValue( + @NotNull Function0 computable, + @NotNull T onRecursiveCall + ) { + return storageManager.createRecursionTolerantLazyValue(computable, onRecursiveCall); + } + + @NotNull + @Override + public NotNullLazyValue createLazyValueWithPostCompute( + @NotNull Function0 computable, + @Nullable Function1 onRecursiveCall, + @NotNull Function1 postCompute + ) { + return storageManager.createLazyValueWithPostCompute(computable, onRecursiveCall, postCompute); + } + + @NotNull + @Override + public NullableLazyValue createNullableLazyValue(@NotNull Function0 computable) { + return storageManager.createNullableLazyValue(computable); + } + + @NotNull + @Override + public NullableLazyValue createRecursionTolerantNullableLazyValue( + @NotNull Function0 computable, + T onRecursiveCall + ) { + return storageManager.createRecursionTolerantNullableLazyValue(computable, onRecursiveCall); + } + + @NotNull + @Override + public NullableLazyValue createNullableLazyValueWithPostCompute( + @NotNull Function0 computable, + @NotNull Function1 postCompute + ) { + return storageManager.createNullableLazyValueWithPostCompute(computable, postCompute); + } + + @Override + public T compute(@NotNull Function0 computable) { + return storageManager.compute(computable); } private static class LockProtectedContext implements BindingContext { diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 128a8c7335c..387852cac9d 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/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(""); 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)); diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java index 9796e136c7a..19af77e2a12 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java @@ -61,7 +61,7 @@ public class LockBasedStorageManager implements StorageManager { } @NotNull - protected MemoizedFunctionToNotNull createMemoizedFunction( + protected MemoizedFunctionToNotNull createMemoizedFunction( @NotNull Function1 compute, @NotNull ConcurrentMap 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 MemoizedFunctionToNotNull createMemoizedFunction( + @NotNull Function1 compute, + @NotNull ConcurrentMap map + ) { + return LockBasedStorageManager.this.createMemoizedFunction(compute, map); + } + + @NotNull + public MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues( + @NotNull Function1 compute, + @NotNull ConcurrentMap map + ) { + return LockBasedStorageManager.this.createMemoizedFunctionWithNullableValues(compute, map); + } + + } } diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index ed33c4f40f7..352ca40da1e 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/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); diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index 802584b9281..d966df5492d 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/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() { @Override diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index 85f8f5221ee..14b642c8dd2 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/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 files, Config config) { - LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); + LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(new LockBasedStorageManager()); FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); ModuleDescriptorImpl module = createJsModule("");