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

Remove 'inner enum' hack & fix Java inner class resolve

Browse Source 
Inner enum was placed into the class object of the outer class. Remove the
hack from frontend, frontend.java & backend. Fix tests

 #KT-1174 In Progress
This commit is contained in:
Alexander Udalov
2012-12-04 20:07:13 +04:00
parent cc6bd6239a
commit b612989eb0
19 changed files with 70 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java
-8
View File
@@ -50,14 +50,6 @@ public final class DescriptorResolverUtils {
return wrapper.getJetClass().isDefined() || wrapper.getJetPackageClass().isDefined();
}
public static boolean isInnerEnum(@NotNull PsiClass innerClass, @Nullable DeclarationDescriptor owner) {
if (!innerClass.isEnum()) return false;
if (!(owner instanceof ClassDescriptor)) return false;
ClassKind kind = ((ClassDescriptor) owner).getKind();
return kind == ClassKind.CLASS || kind == ClassKind.TRAIT || kind == ClassKind.ENUM_CLASS;
}
@NotNull
public static Collection<JetType> getSupertypes(@NotNull ClassOrNamespaceDescriptor classOrNamespaceDescriptor) {
if (classOrNamespaceDescriptor instanceof ClassDescriptor) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+2 -5
View File
@@ -168,10 +168,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
}
@NotNull
public List<ClassDescriptor> resolveInnerClasses(
@NotNull DeclarationDescriptor owner,
@NotNull ClassPsiDeclarationProvider declarationProvider)
{
return innerClassResolver.resolveInnerClasses(owner, declarationProvider);
public List<ClassDescriptor> resolveInnerClasses(@NotNull ClassPsiDeclarationProvider declarationProvider) {
return innerClassResolver.resolveInnerClasses(declarationProvider);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java
-14
View File
@@ -46,7 +46,6 @@ import java.util.Collections;
import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
import static org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils.isInnerEnum;
public final class JavaClassObjectResolver {
@@ -84,10 +83,6 @@ public final class JavaClassObjectResolver {
return null;
}
if (hasInnerEnums(containing, psiClass)) {
return createSyntheticClassObject(containing, psiClass);
}
PsiClass classObjectPsiClass = getClassObjectPsiClass(psiClass);
if (classObjectPsiClass == null) {
return null;
@@ -115,15 +110,6 @@ public final class JavaClassObjectResolver {
return classObjectDescriptor;
}
private static boolean hasInnerEnums(@NotNull ClassDescriptor containing, @NotNull PsiClass psiClass) {
for (PsiClass innerClass : psiClass.getInnerClasses()) {
if (isInnerEnum(innerClass, containing)) {
return true;
}
}
return false;
}
@NotNull
private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(
@NotNull ClassDescriptor containing,
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java
-7
View File
@@ -353,13 +353,6 @@ public final class JavaClassResolver {
throw new IllegalStateException(
"PsiClass not found by name " + containerFqName + ", required to be container declaration of " + getFqName(psiClass));
}
if (DescriptorResolverUtils.isInnerEnum(psiClass, parentClass) && DescriptorResolverUtils.isKotlinClass(psiClass)) {
ClassDescriptor classObjectDescriptor = parentClass.getClassObjectDescriptor();
if (classObjectDescriptor == null) {
throw new IllegalStateException("Class object for a class with inner enum should've been created earlier: " + parentClass);
}
return classObjectDescriptor;
}
return parentClass;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java
+8 -46
View File
@@ -16,14 +16,9 @@
package org.jetbrains.jet.lang.resolve.java.resolver;
import com.google.common.collect.Lists;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiModifier;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
@@ -34,8 +29,6 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
public final class JavaInnerClassResolver {
private JavaClassResolver classResolver;
@@ -49,23 +42,20 @@ public final class JavaInnerClassResolver {
}
@NotNull
public List<ClassDescriptor> resolveInnerClasses(
@NotNull DeclarationDescriptor owner,
@NotNull ClassPsiDeclarationProvider declarationProvider
) {
if (declarationProvider.isStaticMembers() && declarationProvider.getDeclarationOrigin() == KOTLIN) {
return resolveInnerClassesOfClassObject(owner, declarationProvider.getPsiClass());
public List<ClassDescriptor> resolveInnerClasses(@NotNull ClassPsiDeclarationProvider declarationProvider) {
if (declarationProvider.isStaticMembers()) {
return Collections.emptyList();
}
return resolveInnerClasses(owner, declarationProvider.getPsiClass(), declarationProvider.isStaticMembers());
return resolveInnerClasses(declarationProvider.getPsiClass());
}
@NotNull
private List<ClassDescriptor> resolveInnerClasses(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass, boolean isStatic) {
private List<ClassDescriptor> resolveInnerClasses(@NotNull PsiClass psiClass) {
PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
for (PsiClass innerPsiClass : innerPsiClasses) {
if (shouldBeIgnored(owner, psiClass, innerPsiClass, isStatic)) {
if (shouldBeIgnored(innerPsiClass)) {
continue;
}
ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass);
@@ -74,36 +64,8 @@ public final class JavaInnerClassResolver {
return result;
}
private static boolean shouldBeIgnored(DeclarationDescriptor owner, PsiClass psiClass, PsiClass innerPsiClass, boolean isStatic) {
if (innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)
|| DescriptorResolverUtils.isInnerEnum(innerPsiClass, owner)) {
return true;
}
//TODO: this is a hack that puts interfaces and inner classes of interfaces (which are always static)
// inside NonStaticMemberScope
if (innerPsiClass.isInterface() || psiClass.isInterface()) {
return isStatic;
}
else {
return innerPsiClass.hasModifierProperty(PsiModifier.STATIC) != isStatic;
}
}
private List<ClassDescriptor> resolveInnerClassesOfClassObject(@NotNull DeclarationDescriptor classObject, @NotNull PsiClass psiClass) {
if (!DescriptorUtils.isClassObject(classObject)) {
return Collections.emptyList();
}
List<ClassDescriptor> result = Lists.newArrayList();
// If we're a class object, inner enums of our parent need to be put into us
DeclarationDescriptor containingDeclaration = classObject.getContainingDeclaration();
for (PsiClass innerPsiClass : psiClass.getInnerClasses()) {
if (DescriptorResolverUtils.isInnerEnum(innerPsiClass, containingDeclaration)) {
ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass);
result.add(classDescriptor);
}
}
return result;
private static boolean shouldBeIgnored(PsiClass innerPsiClass) {
return innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME);
}
@NotNull
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java
+1 -1
View File
@@ -71,7 +71,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
@NotNull
@Override
protected Collection<ClassDescriptor> computeInnerClasses() {
return getResolver().resolveInnerClasses(descriptor, declarationProvider);
return getResolver().resolveInnerClasses(declarationProvider);
}
@Override
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java
+1 -1
View File
@@ -51,6 +51,6 @@ public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
@NotNull
@Override
protected Collection<ClassDescriptor> computeInnerClasses() {
return getResolver().resolveInnerClasses(descriptor, declarationProvider);
return getResolver().resolveInnerClasses(declarationProvider);
}
}