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.storage.StorageManager;
import org.jetbrains.jet.utils.Printer; import org.jetbrains.jet.utils.Printer;
import java.util.Collection; import java.util.*;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve; 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; protected final D thisDescriptor;
private final MemoizedFunctionToNotNull<Name, List<ClassDescriptor>> classDescriptors; 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<FunctionDescriptor>> functionDescriptors;
private final MemoizedFunctionToNotNull<Name, Set<VariableDescriptor>> propertyDescriptors; private final MemoizedFunctionToNotNull<Name, Set<VariableDescriptor>> propertyDescriptors;
private static class AllDescriptors { private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
private final Collection<DeclarationDescriptor> all = Sets.newLinkedHashSet();
private final Collection<ClassDescriptor> objects = Sets.newLinkedHashSet();
}
private final NotNullLazyValue<AllDescriptors> allDescriptors;
protected AbstractLazyMemberScope( protected AbstractLazyMemberScope(
@NotNull ResolveSession resolveSession, @NotNull ResolveSession resolveSession,
@@ -75,13 +66,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
this.classDescriptors = storageManager.createMemoizedFunction(new Function1<Name, List<ClassDescriptor>>() { this.classDescriptors = storageManager.createMemoizedFunction(new Function1<Name, List<ClassDescriptor>>() {
@Override @Override
public List<ClassDescriptor> invoke(Name name) { public List<ClassDescriptor> invoke(Name name) {
return resolveClassOrObjectDescriptor(name, false); return resolveClassDescriptor(name);
}
});
this.objectDescriptors = storageManager.createMemoizedFunction(new Function1<Name, List<ClassDescriptor>>() {
@Override
public List<ClassDescriptor> invoke(Name name) {
return resolveClassOrObjectDescriptor(name, true);
} }
}); });
@@ -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 @Override
public AllDescriptors invoke() { public Collection<DeclarationDescriptor> invoke() {
return computeAllDescriptors(); return computeAllDescriptors();
} }
}); });
} }
@Nullable @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); Collection<JetClassOrObject> classOrObjectDeclarations = declarationProvider.getClassOrObjectDeclarations(name);
return ContainerUtil.mapNotNull(classOrObjectDeclarations, new Function<JetClassOrObject, ClassDescriptor>() { return ContainerUtil.mapNotNull(classOrObjectDeclarations, new Function<JetClassOrObject, ClassDescriptor>() {
@Override @Override
public ClassDescriptor fun(JetClassOrObject classOrObject) { 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 @Override
public ClassifierDescriptor getClassifier(@NotNull Name name) { public ClassifierDescriptor getClassifier(@NotNull Name name) {
return first(classDescriptors.invoke(name)); return first(classDescriptors.invoke(name));
@@ -132,7 +110,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
@Override @Override
public ClassDescriptor getObjectDescriptor(@NotNull Name name) { public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
return first(objectDescriptors.invoke(name)); return null;
} }
private static <T> T first(@NotNull List<T> list) { private static <T> T first(@NotNull List<T> list) {
@@ -208,7 +186,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
@NotNull @NotNull
@Override @Override
public Collection<ClassDescriptor> getObjectDescriptors() { public Collection<ClassDescriptor> getObjectDescriptors() {
return allDescriptors.invoke().objects; return Collections.emptySet();
} }
@Override @Override
@@ -232,42 +210,28 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
@NotNull @NotNull
@Override @Override
public Collection<DeclarationDescriptor> getAllDescriptors() { public Collection<DeclarationDescriptor> getAllDescriptors() {
return allDescriptors.invoke().all; return allDescriptors.invoke();
} }
@NotNull @NotNull
private AllDescriptors computeAllDescriptors() { private Collection<DeclarationDescriptor> computeAllDescriptors() {
AllDescriptors result = new AllDescriptors(); Collection<DeclarationDescriptor> result = new LinkedHashSet<DeclarationDescriptor>();
for (JetDeclaration declaration : declarationProvider.getAllDeclarations()) { for (JetDeclaration declaration : declarationProvider.getAllDeclarations()) {
if (declaration instanceof JetEnumEntry) { if (declaration instanceof JetClassOrObject) {
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) {
JetClassOrObject classOrObject = (JetClassOrObject) declaration; JetClassOrObject classOrObject = (JetClassOrObject) declaration;
Name name = safeNameForLazyResolve(classOrObject.getNameAsName()); result.addAll(classDescriptors.invoke(safeNameForLazyResolve(classOrObject.getNameAsName())));
result.all.addAll(classDescriptors.invoke(name));
} }
else if (declaration instanceof JetFunction) { else if (declaration instanceof JetFunction) {
JetFunction function = (JetFunction) declaration; JetFunction function = (JetFunction) declaration;
result.all.addAll(getFunctions(safeNameForLazyResolve(function))); result.addAll(getFunctions(safeNameForLazyResolve(function)));
} }
else if (declaration instanceof JetProperty) { else if (declaration instanceof JetProperty) {
JetProperty property = (JetProperty) declaration; JetProperty property = (JetProperty) declaration;
result.all.addAll(getProperties(safeNameForLazyResolve(property))); result.addAll(getProperties(safeNameForLazyResolve(property)));
} }
else if (declaration instanceof JetParameter) { else if (declaration instanceof JetParameter) {
JetParameter parameter = (JetParameter) declaration; JetParameter parameter = (JetParameter) declaration;
Name name = safeNameForLazyResolve(parameter); result.addAll(getProperties(safeNameForLazyResolve(parameter)));
result.all.addAll(getProperties(name));
} }
else if (declaration instanceof JetTypedef || declaration instanceof JetMultiDeclaration) { else if (declaration instanceof JetTypedef || declaration instanceof JetMultiDeclaration) {
// Do nothing for typedefs as they are not supported. // 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); throw new IllegalArgumentException("Unsupported declaration kind: " + declaration);
} }
} }
addExtraDescriptors(result.all); addExtraDescriptors(result);
return result; return result;
} }