From fd8da79b886427c41ce7bafe313b5976dcb9ab8f Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 8 Feb 2013 19:14:18 +0400 Subject: [PATCH] Getting rid of createConcurrentCollection in favor of lazy values --- .../resolve/lazy/AbstractLazyMemberScope.java | 149 ++++++++---------- .../resolve/lazy/LazyClassMemberScope.java | 19 ++- .../resolve/lazy/LazyPackageMemberScope.java | 23 ++- .../resolve/lazy/LockBasedStorageManager.java | 6 - .../jet/lang/resolve/lazy/StorageManager.java | 4 - 5 files changed, 92 insertions(+), 109 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java index 0dc498e70f4..c7ea0b16821 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.google.common.collect.Sets; +import com.intellij.openapi.util.Computable; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -46,8 +47,12 @@ public abstract class AbstractLazyMemberScope> functionDescriptors; private final Function> propertyDescriptors; - private final Collection allDescriptors; - protected volatile boolean allDescriptorsComputed = false; + private static class AllDescriptors { + private final Collection all = Sets.newLinkedHashSet(); + private final Collection objects = Sets.newLinkedHashSet(); + } + + private final LazyValue allDescriptors; protected AbstractLazyMemberScope( @NotNull ResolveSession resolveSession, @@ -85,7 +90,12 @@ public abstract class AbstractLazyMemberScope() { + @Override + public AllDescriptors compute() { + return computeAllDescriptors(); + } + }); } @Nullable @@ -95,14 +105,8 @@ public abstract class AbstractLazyMemberScope getObjectDescriptors() { - getAllDescriptors(); - return objectDescriptors.values(); + return allDescriptors.get().objects; } @Override @@ -223,72 +221,65 @@ public abstract class AbstractLazyMemberScope descriptors) { - assert !allDescriptorsComputed : "getAllDescriptors() has been called already"; - allDescriptors.addAll(descriptors); - } - @NotNull @Override public Collection getAllDescriptors() { - if (!allDescriptorsComputed) { - for (JetDeclaration declaration : declarationProvider.getAllDeclarations()) { - if (declaration instanceof JetEnumEntry) { - JetEnumEntry jetEnumEntry = (JetEnumEntry) declaration; - Name name = safeNameForLazyResolve(jetEnumEntry); - if (name != null) { - getProperties(name); - getObjectDescriptor(name); - } - } - else if (declaration instanceof JetObjectDeclaration) { - JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) declaration; - Name name = safeNameForLazyResolve(objectDeclaration.getNameAsDeclaration()); - if (name != null) { - getProperties(name); - getObjectDescriptor(name); - } - } - else if (declaration instanceof JetClassOrObject) { - JetClassOrObject classOrObject = (JetClassOrObject) declaration; - Name name = safeNameForLazyResolve(classOrObject.getNameAsName()); - if (name != null) { - getClassifier(name); - } - } - else if (declaration instanceof JetFunction) { - JetFunction function = (JetFunction) declaration; - getFunctions(safeNameForLazyResolve(function)); - } - else if (declaration instanceof JetProperty) { - JetProperty property = (JetProperty) declaration; - getProperties(safeNameForLazyResolve(property)); - } - else if (declaration instanceof JetParameter) { - JetParameter parameter = (JetParameter) declaration; - Name name = safeNameForLazyResolve(parameter); - getProperties(name); - } - else if (declaration instanceof JetTypedef || declaration instanceof JetMultiDeclaration) { - // Do nothing for typedefs as they are not supported. - // MultiDeclarations are not supported on global level too. - } - else { - throw new IllegalArgumentException("Unsupported declaration kind: " + declaration); - } - } - addExtraDescriptors(); - allDescriptorsComputed = true; - } - return allDescriptors; + return allDescriptors.get().all; } - protected abstract void addExtraDescriptors(); + @NotNull + private AllDescriptors computeAllDescriptors() { + AllDescriptors result = new AllDescriptors(); + for (JetDeclaration declaration : declarationProvider.getAllDeclarations()) { + if (declaration instanceof JetEnumEntry) { + JetEnumEntry jetEnumEntry = (JetEnumEntry) declaration; + Name name = safeNameForLazyResolve(jetEnumEntry); + if (name != null) { + result.all.addAll(getProperties(name)); + result.objects.add(getObjectDescriptor(name)); + } + } + else if (declaration instanceof JetObjectDeclaration) { + JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) declaration; + Name name = safeNameForLazyResolve(objectDeclaration.getNameAsDeclaration()); + if (name != null) { + result.all.addAll(getProperties(name)); + result.objects.add(getObjectDescriptor(name)); + } + } + else if (declaration instanceof JetClassOrObject) { + JetClassOrObject classOrObject = (JetClassOrObject) declaration; + Name name = safeNameForLazyResolve(classOrObject.getNameAsName()); + if (name != null) { + result.all.add(getClassifier(name)); + } + } + else if (declaration instanceof JetFunction) { + JetFunction function = (JetFunction) declaration; + result.all.addAll(getFunctions(safeNameForLazyResolve(function))); + } + else if (declaration instanceof JetProperty) { + JetProperty property = (JetProperty) declaration; + result.all.addAll(getProperties(safeNameForLazyResolve(property))); + } + else if (declaration instanceof JetParameter) { + JetParameter parameter = (JetParameter) declaration; + Name name = safeNameForLazyResolve(parameter); + result.all.addAll(getProperties(name)); + } + else if (declaration instanceof JetTypedef || declaration instanceof JetMultiDeclaration) { + // Do nothing for typedefs as they are not supported. + // MultiDeclarations are not supported on global level too. + } + else { + throw new IllegalArgumentException("Unsupported declaration kind: " + declaration); + } + } + addExtraDescriptors(result.all); + return result; + } + + protected abstract void addExtraDescriptors(@NotNull Collection result); @NotNull @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java index 2c2768d9525..d3468a44c51 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java @@ -282,26 +282,26 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope result) { for (JetType supertype : thisDescriptor.getTypeConstructor().getSupertypes()) { for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) { if (descriptor instanceof FunctionDescriptor) { - getFunctions(descriptor.getName()); + result.addAll(getFunctions(descriptor.getName())); } else if (descriptor instanceof PropertyDescriptor) { - getProperties(descriptor.getName()); + result.addAll(getProperties(descriptor.getName())); } // Nothing else is inherited } } - getFunctions(DescriptorResolver.VALUES_METHOD_NAME); - getFunctions(DescriptorResolver.VALUE_OF_METHOD_NAME); + result.addAll(getFunctions(DescriptorResolver.VALUES_METHOD_NAME)); + result.addAll(getFunctions(DescriptorResolver.VALUE_OF_METHOD_NAME)); - addDataClassMethods(); + addDataClassMethods(result); } - private void addDataClassMethods() { + private void addDataClassMethods(@NotNull Collection result) { if (!KotlinBuiltIns.getInstance().isData(thisDescriptor)) return; ConstructorDescriptor constructor = getPrimaryConstructor(); @@ -313,9 +313,12 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope functions = getFunctions(componentName); if (functions.isEmpty()) break; + + result.addAll(functions); + n++; } - getFunctions(Name.identifier("copy")); + result.addAll(getFunctions(Name.identifier("copy"))); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java index 60f29e62fd4..1ab112a45c8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java @@ -27,6 +27,7 @@ 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 java.util.Collection; import java.util.Set; public class LazyPackageMemberScope extends AbstractLazyMemberScope { @@ -38,12 +39,13 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope() { - @Override - public NamespaceDescriptor fun(Name name) { - return createPackageDescriptor(name); - } - }, StorageManager.MemoizationMode.STRONG); + this.packageDescriptors = resolveSession.getStorageManager().createMemoizedFunctionWithNullableValues( + new Function() { + @Override + public NamespaceDescriptor fun(Name name) { + return createPackageDescriptor(name); + } + }, StorageManager.MemoizationMode.STRONG); } @Override @@ -58,11 +60,8 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope result) { for (FqName packageFqName : declarationProvider.getAllDeclaredPackages()) { - getNamespace(packageFqName.shortName()); + result.add(getNamespace(packageFqName.shortName())); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LockBasedStorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LockBasedStorageManager.java index d1242e37f59..4b83605d7da 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LockBasedStorageManager.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LockBasedStorageManager.java @@ -29,7 +29,6 @@ import org.jetbrains.jet.util.slicedmap.WritableSlice; import java.util.Collection; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.ConcurrentMap; import static org.jetbrains.jet.lang.resolve.lazy.StorageManager.MemoizationMode.WEAK; @@ -86,11 +85,6 @@ public class LockBasedStorageManager implements StorageManager { }; } - @Override - public Collection createConcurrentCollection() { - return new ConcurrentLinkedQueue(); - } - @NotNull @Override public LazyValue createLazyValue(@NotNull Computable computable) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/StorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/StorageManager.java index ff633ac1994..0bb388e002c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/StorageManager.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/StorageManager.java @@ -21,8 +21,6 @@ import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.resolve.BindingTrace; -import java.util.Collection; - public interface StorageManager { /** * Given a function compute: K -> V create a memoized version of it that computes a value only once for each key @@ -34,8 +32,6 @@ public interface StorageManager { @NotNull Function createMemoizedFunctionWithNullableValues(@NotNull Function compute, @NotNull MemoizationMode modeForValues); - Collection createConcurrentCollection(); - @NotNull LazyValue createLazyValue(@NotNull Computable computable);