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/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+1 -21
View File
@@ -186,26 +186,12 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
private void writeInnerClasses() {
// Inner enums are moved by frontend to a class object of outer class, but we want them to be inner for the outer class itself
// (to avoid publicly visible names like A$ClassObject$$B), so they are handled specially in this method
for (ClassDescriptor innerClass : getInnerClassesAndObjects(descriptor)) {
// If it's an inner enum inside a class object, don't write it
// (instead write it to inner classes of this class object's containing class)
if (!isEnumMovedToClassObject(innerClass)) {
writeInnerClass(innerClass, false);
}
writeInnerClass(innerClass, false /* TODO */);
}
ClassDescriptor classObjectDescriptor = descriptor.getClassObjectDescriptor();
if (classObjectDescriptor != null) {
// Process all enums here which were moved to our class object
for (ClassDescriptor innerClass : getInnerClassesAndObjects(classObjectDescriptor)) {
if (isEnumMovedToClassObject(innerClass)) {
writeInnerClass(innerClass, true);
}
}
int innerClassAccess = getVisibilityAccessFlag(classObjectDescriptor) | ACC_FINAL | ACC_STATIC;
v.visitInnerClass(classAsmType.getInternalName() + JvmAbi.CLASS_OBJECT_SUFFIX, classAsmType.getInternalName(),
JvmAbi.CLASS_OBJECT_CLASS_NAME,
@@ -240,12 +226,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
v.visitInnerClass(innerClassInternalName, outerClassInternalName, innerClass.getName().getName(), innerClassAccess);
}
private boolean isEnumMovedToClassObject(ClassDescriptor innerClass) {
// Checks if this is enum, moved to class object by frontend
return Boolean.TRUE.equals(bindingContext.get(BindingContext.IS_ENUM_MOVED_TO_CLASS_OBJECT, innerClass));
}
private void writeClassSignatureIfNeeded(JvmClassSignature signature) {
if (signature.getKotlinGenericSignature() != null || descriptor.getVisibility() != Visibilities.PUBLIC) {
AnnotationVisitor annotationVisitor = v.newAnnotation(JvmStdlibNames.JET_CLASS.getDescriptor(), true);
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);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
-2
View File
@@ -160,8 +160,6 @@ public interface Errors {
// Enum-specific
SimpleDiagnosticFactory<PsiElement> ENUM_NOT_ALLOWED = SimpleDiagnosticFactory.create(ERROR);
SimpleDiagnosticFactory<JetModifierListOwner> ILLEGAL_ENUM_ANNOTATION = SimpleDiagnosticFactory
.create(ERROR, modifierSetPosition(JetTokens.ENUM_KEYWORD));
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java
-1
View File
@@ -162,7 +162,6 @@ public class DefaultErrorMessages {
MAP.put(ENUM_ENTRY_SHOULD_BE_INITIALIZED, "Missing delegation specifier ''{0}''", NAME);
MAP.put(ENUM_ENTRY_ILLEGAL_TYPE, "The type constructor of enum entry should be ''{0}''", NAME);
MAP.put(ENUM_NOT_ALLOWED, "Enum class is not allowed here");
MAP.put(UNINITIALIZED_VARIABLE, "Variable ''{0}'' must be initialized", NAME);
MAP.put(UNINITIALIZED_PARAMETER, "Parameter ''{0}'' is uninitialized here", NAME);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
-2
View File
@@ -228,8 +228,6 @@ public interface BindingContext {
ReadOnlySlice<PsiElement, DeclarationDescriptor> DECLARATION_TO_DESCRIPTOR = Slices.<PsiElement, DeclarationDescriptor>sliceBuilder()
.setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS).build();
WritableSlice<ClassDescriptor, Boolean> IS_ENUM_MOVED_TO_CLASS_OBJECT = Slices.createSimpleSlice();
WritableSlice<JetReferenceExpression, PsiElement> LABEL_TARGET = Slices.<JetReferenceExpression, PsiElement>sliceBuilder().build();
WritableSlice<JetReferenceExpression, Collection<? extends PsiElement>> AMBIGUOUS_LABEL_TARGET =
Slices.<JetReferenceExpression, Collection<? extends PsiElement>>sliceBuilder().build();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
-63
View File
@@ -196,8 +196,6 @@ public class TypeHierarchyResolver {
declaration.accept(collector);
}
collector.finishProcessing();
return forDeferredResolve;
}
@@ -470,8 +468,6 @@ public class TypeHierarchyResolver {
private final NamespaceLikeBuilder owner;
private final Collection<JetDeclarationContainer> forDeferredResolve;
private final List<JetClass> enumsToAddLater = new ArrayList<JetClass>(0);
public ClassifierCollector(@NotNull JetScope outerScope,
@NotNull NamespaceLikeBuilder owner,
@NotNull Collection<JetDeclarationContainer> forDeferredResolve
@@ -501,25 +497,11 @@ public class TypeHierarchyResolver {
@Override
public void visitClass(JetClass klass) {
if (getClassKind(klass) == ClassKind.ENUM_CLASS && inClass()) {
// Enums inside non-static context are put not to owner, but rather into its class object.
// This is handled after visiting all declarations in this class, because we may or may not
// encounter class object to put this enum into.
enumsToAddLater.add(klass);
return;
}
MutableClassDescriptor mutableClassDescriptor = createClassDescriptorForClass(klass, owner.getOwnerForChildren());
owner.addClassifierDescriptor(mutableClassDescriptor);
}
private boolean inClass() {
if (!(owner.getOwnerForChildren() instanceof ClassDescriptor)) return false;
ClassKind kind = ((ClassDescriptor) owner.getOwnerForChildren()).getKind();
return kind == ClassKind.CLASS || kind == ClassKind.ENUM_CLASS || kind == ClassKind.TRAIT;
}
@Override
public void visitObjectDeclaration(JetObjectDeclaration declaration) {
MutableClassDescriptor objectDescriptor =
@@ -673,50 +655,5 @@ public class TypeHierarchyResolver {
context.normalScope.put(container, outerScope);
context.forDeferredResolver.put(container, descriptorForDeferredResolve);
}
@Nullable
private MutableClassDescriptor getOrCreateClassObjectDescriptor() {
ClassDescriptor ownerForChildren = (ClassDescriptor) owner.getOwnerForChildren();
MutableClassDescriptor classObjectDescriptor = (MutableClassDescriptor) ownerForChildren.getClassObjectDescriptor();
if (classObjectDescriptor == null) {
classObjectDescriptor = createClassObjectDescriptor(ownerForChildren, Visibilities.PUBLIC);
NamespaceLikeBuilder.ClassObjectStatus status = owner.setClassObjectDescriptor(classObjectDescriptor);
assert status != NamespaceLikeBuilder.ClassObjectStatus.DUPLICATE :
"Attempting to create an artificial class object where the real one exists: " + ownerForChildren;
if (status == NamespaceLikeBuilder.ClassObjectStatus.NOT_ALLOWED) {
return null;
}
}
return classObjectDescriptor;
}
private void putEnumsIntoOuterClassObject() {
if (enumsToAddLater.isEmpty()) return;
MutableClassDescriptor classObjectDescriptor = getOrCreateClassObjectDescriptor();
if (classObjectDescriptor == null) {
// A class object is not allowed in outer class, so report an error on every declared enum
for (JetClass klass : enumsToAddLater) {
JetModifierList modifierList = klass.getModifierList();
assert modifierList != null : "Enum class without modifier list: " + klass.getText();
ASTNode node = modifierList.getModifierNode(JetTokens.ENUM_KEYWORD);
assert node != null : "Enum class without enum modifier: " + klass.getText();
trace.report(ENUM_NOT_ALLOWED.on(node.getPsi()));
}
return;
}
for (JetClass klass : enumsToAddLater) {
MutableClassDescriptor mutableClassDescriptor = createClassDescriptorForClass(klass, classObjectDescriptor);
trace.record(BindingContext.IS_ENUM_MOVED_TO_CLASS_OBJECT, mutableClassDescriptor);
classObjectDescriptor.getBuilder().addClassifierDescriptor(mutableClassDescriptor);
}
}
private void finishProcessing() {
putEnumsIntoOuterClassObject();
}
}
}
compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt
+2 -2
View File
@@ -1,6 +1,6 @@
class A {
class B {
<!ENUM_NOT_ALLOWED!>enum<!> class E {
inner class B {
enum class <!NESTED_CLASS_NOT_ALLOWED!>E<!> {
ENTRY
}
}
compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt
+2 -2
View File
@@ -3,7 +3,7 @@ class A {
enum class E { ENTRY } // OK
}
class B {
<!ENUM_NOT_ALLOWED!>enum<!> class E { ENTRY }
inner class B {
enum class <!NESTED_CLASS_NOT_ALLOWED!>E<!> { ENTRY }
}
}
compiler/testData/javaDescriptorResolver/staticMembers/Enum_non_static.txt
+5 -5
View File
@@ -12,15 +12,15 @@ public final enum class Enum : jet.Enum<test.Enum> {
public final val C : test.Enum
public final fun valueOf(/*0*/ value : jet.String) : test.Enum
public final fun values() : jet.Array<test.Enum>
public open class Nested : java.lang.Object {
public constructor Nested()
public/*package*/ open fun foo() : Unit
}
}
public open inner class Inner : java.lang.Object {
public constructor Inner()
public/*package*/ open fun bar() : Unit
}
public open class Nested : java.lang.Object {
public constructor Nested()
public/*package*/ open fun foo() : Unit
}
}
compiler/testData/loadKotlinCustom/enum/innerEnumBinary.txt
+9 -13
View File
@@ -3,20 +3,16 @@ package test
internal final class A {
public constructor A()
internal class object <class-object-for-A> {
private constructor <class-object-for-A>()
internal final enum class E : jet.Enum<test.A.E> {
private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal final enum class E : jet.Enum<test.A.E> {
private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal class object <class-object-for-E> {
private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
}
internal class object <class-object-for-E> {
private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
}
}
}
compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectBinary.txt
+11 -11
View File
@@ -5,18 +5,18 @@ internal final class A {
internal class object <class-object-for-A> {
private constructor <class-object-for-A>()
}
internal final enum class E : jet.Enum<test.A.E> {
private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal final enum class E : jet.Enum<test.A.E> {
private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal class object <class-object-for-E> {
private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
}
internal class object <class-object-for-E> {
private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
}
}
}
compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectSource.txt
+15 -15
View File
@@ -5,23 +5,23 @@ internal final class A {
internal class object <class-object-for-A> {
/*primary*/ private constructor <class-object-for-A>()
}
internal final enum class E : jet.Enum<test.A.E> {
/*primary*/ private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal final enum class E : jet.Enum<test.A.E> {
/*primary*/ private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal class object <class-object-for-E> {
/*primary*/ private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
internal class object <class-object-for-E> {
/*primary*/ private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
private enum entry ENTRY : test.A.E {
/*primary*/ private constructor ENTRY()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
}
private enum entry ENTRY : test.A.E {
/*primary*/ private constructor ENTRY()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
}
}
}
compiler/testData/loadKotlinCustom/enum/innerEnumSource.txt
+13 -17
View File
@@ -3,25 +3,21 @@ package test
internal final class A {
/*primary*/ public constructor A()
public class object <class-object-for-A> {
/*primary*/ private constructor <class-object-for-A>()
internal final enum class E : jet.Enum<test.A.E> {
/*primary*/ private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal final enum class E : jet.Enum<test.A.E> {
/*primary*/ private constructor E()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
internal class object <class-object-for-E> {
/*primary*/ private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
internal class object <class-object-for-E> {
/*primary*/ private constructor <class-object-for-E>()
public final val ENTRY : test.A.E
public final fun valueOf(/*0*/ value : jet.String) : test.A.E
public final fun values() : jet.Array<test.A.E>
private enum entry ENTRY : test.A.E {
/*primary*/ private constructor ENTRY()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
}
private enum entry ENTRY : test.A.E {
/*primary*/ private constructor ENTRY()
public final override /*1*/ /*fake_override*/ fun name() : jet.String
public final override /*1*/ /*fake_override*/ fun ordinal() : jet.Int
}
}
}