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

Don't store object descriptors separately in lazy member scope

Browse Source 
Object descriptors are refactored to be the usual classes, so the scope can't
contain any 'objects'
This commit is contained in:
Alexander Udalov
2013-11-15 21:57:42 +04:00
parent 9890f2e5ac
commit c2c4123f64
1 changed files with 18 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java
+18 -54
View File
@@ -37,10 +37,7 @@ import org.jetbrains.jet.storage.NotNullLazyValue;
import org.jetbrains.jet.storage.StorageManager;
import org.jetbrains.jet.utils.Printer;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.*;
import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve;
@@ -50,17 +47,11 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
protected final D thisDescriptor;
private final MemoizedFunctionToNotNull<Name, List<ClassDescriptor>> classDescriptors;
private final MemoizedFunctionToNotNull<Name, List<ClassDescriptor>> objectDescriptors;
private final MemoizedFunctionToNotNull<Name, Set<FunctionDescriptor>> functionDescriptors;
private final MemoizedFunctionToNotNull<Name, Set<VariableDescriptor>> propertyDescriptors;
private static class AllDescriptors {
private final Collection<DeclarationDescriptor> all = Sets.newLinkedHashSet();
private final Collection<ClassDescriptor> objects = Sets.newLinkedHashSet();
}
private final NotNullLazyValue<AllDescriptors> allDescriptors;
private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
protected AbstractLazyMemberScope(
@NotNull ResolveSession resolveSession,
@@ -75,13 +66,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
this.classDescriptors = storageManager.createMemoizedFunction(new Function1<Name, List<ClassDescriptor>>() {
@Override
public List<ClassDescriptor> invoke(Name name) {
return resolveClassOrObjectDescriptor(name, false);
}
});
this.objectDescriptors = storageManager.createMemoizedFunction(new Function1<Name, List<ClassDescriptor>>() {
@Override
public List<ClassDescriptor> invoke(Name name) {
return resolveClassOrObjectDescriptor(name, true);
return resolveClassDescriptor(name);
}
});
@@ -98,33 +83,26 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
}
});
this.allDescriptors = storageManager.createLazyValue(new Function0<AllDescriptors>() {
this.allDescriptors = storageManager.createLazyValue(new Function0<Collection<DeclarationDescriptor>>() {
@Override
public AllDescriptors invoke() {
public Collection<DeclarationDescriptor> invoke() {
return computeAllDescriptors();
}
});
}
@Nullable
private List<ClassDescriptor> resolveClassOrObjectDescriptor(@NotNull final Name name, final boolean object) {
private List<ClassDescriptor> resolveClassDescriptor(@NotNull final Name name) {
Collection<JetClassOrObject> classOrObjectDeclarations = declarationProvider.getClassOrObjectDeclarations(name);
return ContainerUtil.mapNotNull(classOrObjectDeclarations, new Function<JetClassOrObject, ClassDescriptor>() {
@Override
public ClassDescriptor fun(JetClassOrObject classOrObject) {
if (object != declaresObjectOrEnumConstant(classOrObject)) return null;
return new LazyClassDescriptor(resolveSession, thisDescriptor, name,
JetClassInfoUtil.createClassLikeInfo(classOrObject));
return new LazyClassDescriptor(resolveSession, thisDescriptor, name, JetClassInfoUtil.createClassLikeInfo(classOrObject));
}
});
}
private static boolean declaresObjectOrEnumConstant(JetClassOrObject declaration) {
return declaration instanceof JetObjectDeclaration || declaration instanceof JetEnumEntry;
}
@Override
public ClassifierDescriptor getClassifier(@NotNull Name name) {
return first(classDescriptors.invoke(name));
@@ -132,7 +110,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
@Override
public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
return first(objectDescriptors.invoke(name));
return null;
}
private static <T> T first(@NotNull List<T> list) {
@@ -208,7 +186,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
@NotNull
@Override
public Collection<ClassDescriptor> getObjectDescriptors() {
return allDescriptors.invoke().objects;
return Collections.emptySet();
}
@Override
@@ -232,42 +210,28 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
return allDescriptors.invoke().all;
return allDescriptors.invoke();
}
@NotNull
private AllDescriptors computeAllDescriptors() {
AllDescriptors result = new AllDescriptors();
private Collection<DeclarationDescriptor> computeAllDescriptors() {
Collection<DeclarationDescriptor> result = new LinkedHashSet<DeclarationDescriptor>();
for (JetDeclaration declaration : declarationProvider.getAllDeclarations()) {
if (declaration instanceof JetEnumEntry) {
JetEnumEntry jetEnumEntry = (JetEnumEntry) declaration;
Name name = safeNameForLazyResolve(jetEnumEntry);
result.all.addAll(getProperties(name));
result.objects.add(getObjectDescriptor(name));
}
else if (declaration instanceof JetObjectDeclaration) {
JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) declaration;
Name name = safeNameForLazyResolve(objectDeclaration);
result.all.addAll(getProperties(name));
result.objects.add(getObjectDescriptor(name));
}
else if (declaration instanceof JetClassOrObject) {
if (declaration instanceof JetClassOrObject) {
JetClassOrObject classOrObject = (JetClassOrObject) declaration;
Name name = safeNameForLazyResolve(classOrObject.getNameAsName());
result.all.addAll(classDescriptors.invoke(name));
result.addAll(classDescriptors.invoke(safeNameForLazyResolve(classOrObject.getNameAsName())));
}
else if (declaration instanceof JetFunction) {
JetFunction function = (JetFunction) declaration;
result.all.addAll(getFunctions(safeNameForLazyResolve(function)));
result.addAll(getFunctions(safeNameForLazyResolve(function)));
}
else if (declaration instanceof JetProperty) {
JetProperty property = (JetProperty) declaration;
result.all.addAll(getProperties(safeNameForLazyResolve(property)));
result.addAll(getProperties(safeNameForLazyResolve(property)));
}
else if (declaration instanceof JetParameter) {
JetParameter parameter = (JetParameter) declaration;
Name name = safeNameForLazyResolve(parameter);
result.all.addAll(getProperties(name));
result.addAll(getProperties(safeNameForLazyResolve(parameter)));
}
else if (declaration instanceof JetTypedef || declaration instanceof JetMultiDeclaration) {
// Do nothing for typedefs as they are not supported.
@@ -277,7 +241,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
throw new IllegalArgumentException("Unsupported declaration kind: " + declaration);
}
}
addExtraDescriptors(result.all);
addExtraDescriptors(result);
return result;
}