diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java index 3ba23c787e7..d0330634589 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java @@ -25,8 +25,6 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.storage.MemoizedFunctionToNullable; import org.jetbrains.jet.storage.StorageManager; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.STRONG; - public abstract class AbstractDescriptorFinder implements DescriptorFinder { private final MemoizedFunctionToNullable findClass; @@ -52,7 +50,7 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder { classDescriptorCreated(classDescriptor); return classDescriptor; } - }, STRONG); + }); } @Nullable diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java index 469ceef1f4e..e7fa42e2e5e 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java @@ -37,8 +37,6 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.STRONG; - public class TypeDeserializer { public interface TypeParameterResolver { @@ -99,7 +97,7 @@ public class TypeDeserializer { public ClassDescriptor invoke(Integer fqNameIndex) { return computeClassDescriptor(fqNameIndex); } - }, STRONG); + }); } /* package */ DescriptorFinder getDescriptorFinder() { diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java index 913d5e4e5ea..a3e90b386ca 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java @@ -45,7 +45,6 @@ import java.util.*; import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE; import static org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.STRONG; public class DeserializedClassDescriptor extends AbstractClassDescriptor implements ClassDescriptor { @@ -497,7 +496,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme descriptorFinder.findClass(classId.createNestedClassId(name)) : null; } - }, STRONG); + }); } @NotNull diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java index 8add30c7564..a9b34e398fc 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java @@ -33,8 +33,6 @@ import org.jetbrains.jet.storage.StorageManager; import java.util.*; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.STRONG; - public abstract class DeserializedMemberScope implements JetScope { private static final Filter FUNCTION = new Filter() { @@ -78,13 +76,13 @@ public abstract class DeserializedMemberScope implements JetScope { public Collection invoke(Name name) { return computeFunctions(name); } - }, STRONG); + }); this.properties = storageManager.createMemoizedFunction(new Function1>() { @Override public Collection invoke(Name name) { return computeProperties(name); } - }, STRONG); + }); this.allDescriptors = storageManager.createLazyValue(new Function0>() { @Override public Collection invoke() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java index 3c499763efc..5b30c261761 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java @@ -39,7 +39,6 @@ import java.util.List; import java.util.Set; import static org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupMode; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.STRONG; public class LazyImportScope implements JetScope { private final ResolveSession resolveSession; @@ -135,7 +134,7 @@ public class LazyImportScope implements JetScope { public ImportDirectiveResolveCache invoke(JetImportDirective directive) { return new ImportDirectiveResolveCache(directive); } - }, STRONG); + }); NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); if (rootPackageDescriptor == null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index d7eba239399..e53cea6792b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java @@ -36,8 +36,6 @@ import org.jetbrains.jet.storage.NotNullLazyValue; import java.util.Collection; import java.util.List; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.WEAK; - public class ScopeProvider { private final ResolveSession resolveSession; @@ -48,12 +46,12 @@ public class ScopeProvider { public ScopeProvider(@NotNull ResolveSession resolveSession) { this.resolveSession = resolveSession; - this.fileScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function1() { + this.fileScopes = resolveSession.getStorageManager().createWeaklyRetainedMemoizedFunction(new Function1() { @Override public JetScope invoke(@NotNull JetFile file) { return createFileScope(file); } - }, WEAK); + }); this.defaultImportsScope = resolveSession.getStorageManager().createLazyValue(new Function0() { @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java index faba7ee4b0e..4e3e6c5782e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java @@ -76,7 +76,7 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF public PackageMemberDeclarationProvider invoke(FqName fqName) { return createPackageMemberDeclarationProvider(fqName); } - }, StorageManager.ReferenceKind.STRONG); + }); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java index 34beab6ebf5..30a89c31b2c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java @@ -42,7 +42,6 @@ import java.util.List; import java.util.Set; import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.STRONG; public abstract class AbstractLazyMemberScope implements JetScope { protected final ResolveSession resolveSession; @@ -77,26 +76,26 @@ public abstract class AbstractLazyMemberScope invoke(Name name) { return resolveClassOrObjectDescriptor(name, false); } - }, STRONG); + }); this.objectDescriptors = storageManager.createMemoizedFunction(new Function1>() { @Override public List invoke(Name name) { return resolveClassOrObjectDescriptor(name, true); } - }, STRONG); + }); this.functionDescriptors = storageManager.createMemoizedFunction(new Function1>() { @Override public Set invoke(Name name) { return doGetFunctions(name); } - }, STRONG); + }); this.propertyDescriptors = storageManager.createMemoizedFunction(new Function1>() { @Override public Set invoke(Name name) { return doGetProperties(name); } - }, STRONG); + }); this.allDescriptors = storageManager.createLazyValue(new Function0() { @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java index 5baab77b42e..3254c5b1bd4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java @@ -29,7 +29,6 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.storage.MemoizedFunctionToNullable; -import org.jetbrains.jet.storage.StorageManager; import java.util.Collection; import java.util.Set; @@ -49,7 +48,7 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope MemoizedFunctionToNotNull createWeaklyRetainedMemoizedFunction(@NotNull Function1 compute); + + @NotNull + MemoizedFunctionToNullable createWeaklyRetainedMemoizedFunctionWithNullableValues(@NotNull Function1 compute); + @NotNull BindingTrace createSafeTrace(@NotNull BindingTrace originalTrace); } 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 d993a036085..7b479217833 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 @@ -17,6 +17,8 @@ package org.jetbrains.jet.lang.resolve.lazy.storage; import com.google.common.collect.ImmutableMap; +import com.intellij.util.containers.ConcurrentWeakValueHashMap; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; @@ -25,6 +27,8 @@ 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.util.slicedmap.ReadOnlySlice; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -32,6 +36,23 @@ import java.util.Collection; import java.util.concurrent.locks.Lock; public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager implements LazyResolveStorageManager { + + @Override + @NotNull + public MemoizedFunctionToNotNull createWeaklyRetainedMemoizedFunction( + @NotNull Function1 compute + ) { + return super.createMemoizedFunction(compute, new ConcurrentWeakValueHashMap()); + } + + @NotNull + @Override + public MemoizedFunctionToNullable createWeaklyRetainedMemoizedFunctionWithNullableValues( + @NotNull Function1 compute + ) { + return super.createMemoizedFunctionWithNullableValues(compute, new ConcurrentWeakValueHashMap()); + } + @NotNull @Override public BindingTrace createSafeTrace(@NotNull BindingTrace originalTrace) { diff --git a/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java b/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java index 03c08e4b158..5c6d3e5aac4 100644 --- a/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java +++ b/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java @@ -9,8 +9,6 @@ import java.util.Arrays; import java.util.Collection; import java.util.List; -import static org.jetbrains.jet.storage.StorageManager.ReferenceKind.STRONG; - public class StorageManagerTest extends TestCase { private StorageManager m; @@ -102,31 +100,31 @@ public class StorageManagerTest extends TestCase { public void testFunctionComputesOnce() throws Exception { CounterFunction counter = new CounterFunction(); - MemoizedFunctionToNotNull f = m.createMemoizedFunction(counter, STRONG); + MemoizedFunctionToNotNull f = m.createMemoizedFunction(counter); doTestComputesOnce(apply(f, "ok"), "ok1", counter); } public void testNullableFunctionComputesOnce() throws Exception { CounterFunction counter = new CounterFunction(); - MemoizedFunctionToNullable f = m.createMemoizedFunctionWithNullableValues(counter, STRONG); + MemoizedFunctionToNullable f = m.createMemoizedFunctionWithNullableValues(counter); doTestComputesOnce(apply(f, "ok"), "ok1", counter); } public void testNullIsNotConfusedForNotComputedInFunction() throws Exception { CounterFunctionToNull counter = new CounterFunctionToNull(); - MemoizedFunctionToNullable f = m.createMemoizedFunctionWithNullableValues(counter, STRONG); + MemoizedFunctionToNullable f = m.createMemoizedFunctionWithNullableValues(counter); doTestComputesOnce(apply(f, ""), null, counter); } public void testFunctionPreservesExceptions() throws Exception { ExceptionCounterFunction counter = new ExceptionCounterFunction(); - MemoizedFunctionToNotNull f = m.createMemoizedFunction(counter, STRONG); + MemoizedFunctionToNotNull f = m.createMemoizedFunction(counter); doTestExceptionPreserved(apply(f, ""), UnsupportedOperationException.class, counter); } public void testNullableFunctionPreservesExceptions() throws Exception { ExceptionCounterFunction counter = new ExceptionCounterFunction(); - MemoizedFunctionToNullable f = m.createMemoizedFunctionWithNullableValues(counter, STRONG); + MemoizedFunctionToNullable f = m.createMemoizedFunctionWithNullableValues(counter); doTestExceptionPreserved(apply(f, ""), UnsupportedOperationException.class, counter); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java index 49341206263..40f3f30d3e5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java @@ -42,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.storage.LockBasedStorageManager; import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; -import org.jetbrains.jet.storage.StorageManager; import javax.inject.Inject; import java.io.IOException; @@ -75,7 +74,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer return Collections.emptyMap(); } } - }, StorageManager.ReferenceKind.STRONG); + }); @Inject public void setJavaClassResolver(JavaClassResolver javaClassResolver) { 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 1d4782fed56..171f6a53ea6 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.storage; -import com.intellij.util.containers.ConcurrentWeakValueHashMap; import jet.Function0; import jet.Function1; import org.jetbrains.annotations.NotNull; @@ -50,24 +49,30 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override - public MemoizedFunctionToNotNull createMemoizedFunction( - @NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind + public MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute) { + return createMemoizedFunction(compute, new ConcurrentHashMap()); + } + + @NotNull + protected MemoizedFunctionToNotNull createMemoizedFunction( + @NotNull Function1 compute, + @NotNull ConcurrentMap map ) { - ConcurrentMap map = createConcurrentMap(valuesReferenceKind); return new MapBasedMemoizedFunctionToNotNull(lock, map, compute); } @NotNull @Override - public MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues( - @NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind - ) { - ConcurrentMap map = createConcurrentMap(valuesReferenceKind); - return new MapBasedMemoizedFunction(lock, map, compute); + public MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute) { + return createMemoizedFunctionWithNullableValues(compute, new ConcurrentHashMap()); } - private static ConcurrentMap createConcurrentMap(ReferenceKind referenceKind) { - return (referenceKind == ReferenceKind.WEAK) ? new ConcurrentWeakValueHashMap() : new ConcurrentHashMap(); + @NotNull + protected MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues( + @NotNull Function1 compute, + @NotNull ConcurrentMap map + ) { + return new MapBasedMemoizedFunction(lock, map, compute); } @NotNull diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java index 290775e3f8b..160f01da5c6 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java @@ -30,9 +30,9 @@ public interface StorageManager { * NOTE: if compute() has side-effects the WEAK reference kind is dangerous: the side-effects will be repeated if */ @NotNull - MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind); + MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute); @NotNull - MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind); + MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute); @NotNull NotNullLazyValue createLazyValue(@NotNull Function0 computable); @@ -69,9 +69,4 @@ public interface StorageManager { NullableLazyValue createNullableLazyValueWithPostCompute(@NotNull Function0 computable, @NotNull Function1 postCompute); T compute(@NotNull Function0 computable); - - enum ReferenceKind { - STRONG, - WEAK - } } diff --git a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index 61c6c470275..d56edc9ac8f 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -39,13 +39,13 @@ import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor; import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyPackageDescriptor; -import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; -import org.jetbrains.jet.storage.StorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.LazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.TypeConstructor; +import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; import java.util.Collection; import java.util.Collections; @@ -66,14 +66,14 @@ public class ResolveElementCache { @Nullable @Override public Result> compute() { - StorageManager manager = ResolveElementCache.this.resolveSession.getStorageManager(); + LazyResolveStorageManager manager = ResolveElementCache.this.resolveSession.getStorageManager(); MemoizedFunctionToNotNull elementsCacheFunction = - manager.createMemoizedFunction(new Function1() { + manager.createWeaklyRetainedMemoizedFunction(new Function1() { @Override public BindingContext invoke(JetElement jetElement) { return elementAdditionalResolve(jetElement); } - }, StorageManager.ReferenceKind.WEAK); + }); return Result.create(elementsCacheFunction, PsiModificationTracker.MODIFICATION_COUNT); }