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

Change enum entry resolution strategy in JDR

Browse Source 
Enum entry is now resolved into a class with a class object, which inherits
from the former class, as in the other parts of the compiler. Create a special
class EnumEntrySyntheticClassDescriptor which will be reused in deserialization
later
This commit is contained in:
Alexander Udalov
2013-11-13 20:32:28 +04:00
parent 57678a5506
commit 83ef095093
14 changed files with 482 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPropertyDescriptorForObject.java
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java.descriptor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.Visibility;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorForObjectImpl;
import org.jetbrains.jet.lang.resolve.name.Name;
import java.util.List;
public class JavaPropertyDescriptorForObject extends PropertyDescriptorForObjectImpl implements JavaCallableMemberDescriptor {
public JavaPropertyDescriptorForObject(
@NotNull ClassOrNamespaceDescriptor containingDeclaration,
@NotNull List<AnnotationDescriptor> annotations,
@NotNull Visibility visibility,
@NotNull Name name,
@NotNull ClassDescriptor objectClass
) {
super(containingDeclaration, annotations, visibility, name, objectClass);
}
}
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java
+9 -30
View File
@@ -18,22 +18,19 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPropertyDescriptor;
import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPropertyDescriptorForObject;
import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers;
import org.jetbrains.jet.lang.resolve.java.structure.JavaField;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeUtils;
import javax.inject.Inject;
import java.util.*;
import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClassObject;
import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.resolveOverrides;
public final class JavaPropertyResolver {
@@ -70,6 +67,10 @@ public final class JavaPropertyResolver {
@NotNull
public Set<VariableDescriptor> resolveFieldGroup(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) {
if (isEnumClassObject(owner)) {
return Collections.emptySet();
}
Name propertyName = members.getName();
List<JavaField> fields = members.getFields();
@@ -100,9 +101,12 @@ public final class JavaPropertyResolver {
@NotNull
private PropertyDescriptor resolveProperty(@NotNull ClassOrNamespaceDescriptor owner, @NotNull Name name, @NotNull JavaField field) {
assert !field.isEnumEntry() : "Enum entries are resolved into classes, not into properties: " + name;
boolean isVar = !field.isFinal();
PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, name, field, isVar);
PropertyDescriptorImpl propertyDescriptor =
new JavaPropertyDescriptor(owner, annotationResolver.resolveAnnotations(field), field.getVisibility(), isVar, name);
propertyDescriptor.initialize(null, null);
TypeVariableResolver typeVariableResolver =
@@ -129,31 +133,6 @@ public final class JavaPropertyResolver {
return propertyDescriptor;
}
@NotNull
private PropertyDescriptorImpl createPropertyDescriptor(
@NotNull ClassOrNamespaceDescriptor owner,
@NotNull Name propertyName,
@NotNull JavaField field,
boolean isVar
) {
List<AnnotationDescriptor> annotations = annotationResolver.resolveAnnotations(field);
Visibility visibility = field.getVisibility();
if (field.isEnumEntry()) {
assert !isVar : "Enum entries should be immutable.";
assert DescriptorUtils.isEnumClassObject(owner) : "Enum entries should be put into class object of enum only: " + owner;
//TODO: this is a hack to indicate that this enum entry is an object
// class descriptor for enum entries is not used by backends so for now this should be safe to use
ClassDescriptorImpl dummyClassDescriptorForEnumEntryObject =
new ClassDescriptorImpl(owner, propertyName, Modality.FINAL, Collections.<JetType>emptyList());
dummyClassDescriptorForEnumEntryObject.initialize(JetScope.EMPTY, Collections.<ConstructorDescriptor>emptySet(), null);
return new JavaPropertyDescriptorForObject(owner, annotations, visibility, propertyName,
dummyClassDescriptorForEnumEntryObject);
}
return new JavaPropertyDescriptor(owner, annotations, visibility, isVar, propertyName);
}
@NotNull
private JetType getPropertyType(@NotNull JavaField field, @NotNull TypeVariableResolver typeVariableResolver) {
JetType propertyType = typeTransformer.transformToType(field.getType(), typeVariableResolver);
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java
+2 -18
View File
@@ -39,8 +39,6 @@ public abstract class JavaBaseScope extends JetScopeImpl {
private final Map<Name, Set<VariableDescriptor>> propertyDescriptors = new HashMap<Name, Set<VariableDescriptor>>();
@Nullable
private Collection<DeclarationDescriptor> allDescriptors = null;
@Nullable
private Set<ClassDescriptor> objectDescriptors = null;
@NotNull
protected final ClassOrNamespaceDescriptor descriptor;
@@ -125,17 +123,14 @@ public abstract class JavaBaseScope extends JetScopeImpl {
protected Collection<DeclarationDescriptor> computeAllDescriptors() {
Collection<DeclarationDescriptor> result = new HashSet<DeclarationDescriptor>();
result.addAll(computeFieldAndFunctionDescriptors());
result.addAll(filterObjects(getInnerClasses(), false));
result.addAll(getInnerClasses());
return result;
}
@NotNull
@Override
public Set<ClassDescriptor> getObjectDescriptors() {
if (objectDescriptors == null) {
objectDescriptors = new HashSet<ClassDescriptor>(filterObjects(getInnerClasses(), true));
}
return objectDescriptors;
return Collections.emptySet();
}
@NotNull
@@ -162,17 +157,6 @@ public abstract class JavaBaseScope extends JetScopeImpl {
return innerClasses;
}
@NotNull
private static Collection<ClassDescriptor> filterObjects(@NotNull Collection<ClassDescriptor> classes, boolean objects) {
List<ClassDescriptor> result = new ArrayList<ClassDescriptor>();
for (ClassDescriptor descriptor : classes) {
if (descriptor.getKind().isSingleton() == objects) {
result.add(descriptor);
}
}
return result;
}
@TestOnly
@Override
public void printScopeStructure(@NotNull Printer p) {
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java
+8 -21
View File
@@ -52,8 +52,13 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
return memberResolver.resolveFunctionGroupForClass(members, descriptor);
}
@NotNull
private Map<Name, ClassDescriptor> getInnerClassesMap() {
@Override
public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
return null;
}
@Override
public ClassifierDescriptor getClassifier(@NotNull Name name) {
if (innerClassesMap == null) {
Collection<ClassDescriptor> innerClasses = getInnerClasses();
innerClassesMap = new HashMap<Name, ClassDescriptor>();
@@ -61,24 +66,6 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
innerClassesMap.put(innerClass.getName(), innerClass);
}
}
return innerClassesMap;
}
@Override
public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
ClassDescriptor innerClass = getInnerClassesMap().get(name);
if (innerClass != null && innerClass.getKind().isSingleton()) {
return innerClass;
}
return null;
}
@Override
public ClassifierDescriptor getClassifier(@NotNull Name name) {
ClassDescriptor innerClass = getInnerClassesMap().get(name);
if (innerClass == null || innerClass.getKind().isSingleton()) {
return null;
}
return innerClass;
return innerClassesMap.get(name);
}
}
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaEnumClassObjectScope.java
+40 -2
View File
@@ -16,14 +16,24 @@
package org.jetbrains.jet.lang.resolve.java.scope;
import jet.Function0;
import jet.Function1;
import kotlin.KotlinPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.EnumEntrySyntheticClassDescriptor;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaField;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import org.jetbrains.jet.storage.NotNullLazyValue;
import org.jetbrains.jet.storage.StorageManager;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class JavaEnumClassObjectScope extends JavaClassMembersScope {
public JavaEnumClassObjectScope(
@@ -37,6 +47,34 @@ public class JavaEnumClassObjectScope extends JavaClassMembersScope {
@NotNull
@Override
protected Collection<ClassDescriptor> computeInnerClasses() {
return Collections.emptyList();
List<ClassDescriptor> result = new ArrayList<ClassDescriptor>();
final Collection<NamedMembers> enumNonStaticMembers = membersProvider.allMembers();
NotNullLazyValue<Collection<Name>> enumMemberNames =
LockBasedStorageManager.NO_LOCKS.createLazyValue(new Function0<Collection<Name>>() {
@Override
public Collection<Name> invoke() {
return KotlinPackage.map(enumNonStaticMembers, new Function1<NamedMembers, Name>() {
@Override
public Name invoke(@NotNull NamedMembers members) {
return members.getName();
}
});
}
});
for (NamedMembers members : enumNonStaticMembers) {
for (JavaField field : members.getFields()) {
if (field.isEnumEntry()) {
EnumEntrySyntheticClassDescriptor enumEntry = EnumEntrySyntheticClassDescriptor
.create(LockBasedStorageManager.NO_LOCKS, (ClassDescriptor) descriptor, members.getName(), enumMemberNames);
result.add(enumEntry);
break;
}
}
}
return result;
}
}