azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Getting rid of createConcurrentCollection in favor of lazy values

Browse Source
This commit is contained in:
Andrey Breslav
2013-02-08 19:14:18 +04:00
parent 6f851845c6
commit fd8da79b88
5 changed files with 92 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java
+70 -79
View File
@@ -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<D extends DeclarationDescriptor, D
private final Function<Name, Set<FunctionDescriptor>> functionDescriptors;
private final Function<Name, Set<VariableDescriptor>> propertyDescriptors;
private final Collection<DeclarationDescriptor> allDescriptors;
protected volatile boolean allDescriptorsComputed = false;
private static class AllDescriptors {
private final Collection<DeclarationDescriptor> all = Sets.newLinkedHashSet();
private final Collection<ClassDescriptor> objects = Sets.newLinkedHashSet();
}
private final LazyValue<AllDescriptors> allDescriptors;
protected AbstractLazyMemberScope(
@NotNull ResolveSession resolveSession,
@@ -85,7 +90,12 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
}
}, STRONG);
this.allDescriptors = storageManager.createConcurrentCollection();
this.allDescriptors = storageManager.createLazyValue(new Computable<AllDescriptors>() {
@Override
public AllDescriptors compute() {
return computeAllDescriptors();
}
});
}
@Nullable
@@ -95,14 +105,8 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
for (JetClassOrObject classOrObjectDeclaration : classOrObjectDeclarations) {
if (object != declaresObjectOrEnumConstant(classOrObjectDeclaration)) continue;
ClassDescriptor classDescriptor = new LazyClassDescriptor(resolveSession, thisDescriptor, name,
JetClassInfoUtil.createClassLikeInfo(classOrObjectDeclaration));
if (!object) {
registerDescriptor(classDescriptor);
}
return classDescriptor;
return new LazyClassDescriptor(resolveSession, thisDescriptor, name,
JetClassInfoUtil.createClassLikeInfo(classOrObjectDeclaration));
}
return null;
}
@@ -141,9 +145,6 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
getNonDeclaredFunctions(name, result);
if (!result.isEmpty()) {
registerDescriptors(result);
}
return result;
}
@@ -186,8 +187,6 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
getNonDeclaredProperties(name, result);
registerDescriptors(result);
return result;
}
@@ -196,8 +195,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
@NotNull
@Override
public Collection<ClassDescriptor> getObjectDescriptors() {
getAllDescriptors();
return objectDescriptors.values();
return allDescriptors.get().objects;
}
@Override
@@ -223,72 +221,65 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
throw new UnsupportedOperationException(); // TODO
}
protected void registerDescriptor(@NotNull DeclarationDescriptor descriptor) {
assert !allDescriptorsComputed : "getAllDescriptors() has been called already";
allDescriptors.add(descriptor);
}
protected void registerDescriptors(@NotNull Collection<? extends DeclarationDescriptor> descriptors) {
assert !allDescriptorsComputed : "getAllDescriptors() has been called already";
allDescriptors.addAll(descriptors);
}
@NotNull
@Override
public Collection<DeclarationDescriptor> 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<DeclarationDescriptor> result);
@NotNull
@Override
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java
+11 -8
View File
@@ -282,26 +282,26 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
}
@Override
protected void addExtraDescriptors() {
protected void addExtraDescriptors(@NotNull Collection<DeclarationDescriptor> 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<DeclarationDescriptor> result) {
if (!KotlinBuiltIns.getInstance().isData(thisDescriptor)) return;
ConstructorDescriptor constructor = getPrimaryConstructor();
@@ -313,9 +313,12 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
Name componentName = Name.identifier(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX + n);
Set<FunctionDescriptor> functions = getFunctions(componentName);
if (functions.isEmpty()) break;
result.addAll(functions);
n++;
}
getFunctions(Name.identifier("copy"));
result.addAll(getFunctions(Name.identifier("copy")));
}
@Override
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java
+11 -12
View File
@@ -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<NamespaceDescriptor, PackageMemberDeclarationProvider> {
@@ -38,12 +39,13 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
@NotNull NamespaceDescriptor thisPackage) {
super(resolveSession, declarationProvider, thisPackage);
this.packageDescriptors = resolveSession.getStorageManager().createMemoizedFunctionWithNullableValues(new Function<Name, NamespaceDescriptor>() {
@Override
public NamespaceDescriptor fun(Name name) {
return createPackageDescriptor(name);
}
}, StorageManager.MemoizationMode.STRONG);
this.packageDescriptors = resolveSession.getStorageManager().createMemoizedFunctionWithNullableValues(
new Function<Name, NamespaceDescriptor>() {
@Override
public NamespaceDescriptor fun(Name name) {
return createPackageDescriptor(name);
}
}, StorageManager.MemoizationMode.STRONG);
}
@Override
@@ -58,11 +60,8 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
PackageMemberDeclarationProvider packageMemberDeclarationProvider = resolveSession.getDeclarationProviderFactory().getPackageMemberDeclarationProvider(
DescriptorUtils.getFQName(thisDescriptor).child(name).toSafe());
assert packageMemberDeclarationProvider != null : "Package is declared, but declaration provider is not found: " + name;
NamespaceDescriptor namespaceDescriptor = new LazyPackageDescriptor(thisDescriptor, name, resolveSession, packageMemberDeclarationProvider);
registerDescriptor(namespaceDescriptor);
return namespaceDescriptor;
return new LazyPackageDescriptor(thisDescriptor, name, resolveSession, packageMemberDeclarationProvider);
}
@Override
@@ -94,9 +93,9 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
}
@Override
protected void addExtraDescriptors() {
protected void addExtraDescriptors(@NotNull Collection<DeclarationDescriptor> result) {
for (FqName packageFqName : declarationProvider.getAllDeclaredPackages()) {
getNamespace(packageFqName.shortName());
result.add(getNamespace(packageFqName.shortName()));
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LockBasedStorageManager.java
-6
View File
@@ -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 <E> Collection<E> createConcurrentCollection() {
return new ConcurrentLinkedQueue<E>();
}
@NotNull
@Override
public <T> LazyValue<T> createLazyValue(@NotNull Computable<T> computable) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/StorageManager.java
-4
View File
@@ -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
<K, V> Function<K, V> createMemoizedFunctionWithNullableValues(@NotNull Function<K, V> compute, @NotNull MemoizationMode modeForValues);
<E> Collection<E> createConcurrentCollection();
@NotNull
<T> LazyValue<T> createLazyValue(@NotNull Computable<T> computable);