From b612989eb0a1d610e620285da96ae48ae0f1a6e5 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 4 Dec 2012 20:07:13 +0400 Subject: [PATCH] Remove 'inner enum' hack & fix Java inner class resolve 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 --- .../codegen/ImplementationBodyCodegen.java | 22 +------ .../resolve/java/DescriptorResolverUtils.java | 8 --- .../resolve/java/JavaDescriptorResolver.java | 7 +-- .../resolver/JavaClassObjectResolver.java | 14 ----- .../java/resolver/JavaClassResolver.java | 7 --- .../java/resolver/JavaInnerClassResolver.java | 54 +++------------- .../java/scope/JavaClassMembersScope.java | 2 +- .../scope/JavaScopeForKotlinNamespace.java | 2 +- .../jet/lang/diagnostics/Errors.java | 2 - .../rendering/DefaultErrorMessages.java | 1 - .../jet/lang/resolve/BindingContext.java | 2 - .../lang/resolve/TypeHierarchyResolver.java | 63 ------------------- .../enum/inner/insideInnerClassNotAllowed.kt | 4 +- .../twoEnumsInClassObjectAndInnerClass.kt | 4 +- .../staticMembers/Enum_non_static.txt | 10 +-- .../loadKotlinCustom/enum/innerEnumBinary.txt | 22 +++---- .../innerEnumExistingClassObjectBinary.txt | 22 +++---- .../innerEnumExistingClassObjectSource.txt | 30 ++++----- .../loadKotlinCustom/enum/innerEnumSource.txt | 30 ++++----- 19 files changed, 70 insertions(+), 236 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 55cbab2a240c3..a8660f9b5acf6 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -186,26 +186,12 @@ private void writeOuterClass() { } 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 @@ else if (innerClass.getKind() == ClassKind.ENUM_CLASS) { 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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java index cf191a33a0f50..3d50c17eca194 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -50,14 +50,6 @@ public static boolean isKotlinClass(@NotNull PsiClass psiClass) { 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 getSupertypes(@NotNull ClassOrNamespaceDescriptor classOrNamespaceDescriptor) { if (classOrNamespaceDescriptor instanceof ClassDescriptor) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 3a65075ae7a5d..9f3b927cbcd10 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -168,10 +168,7 @@ public Set resolveFunctionGroup( } @NotNull - public List resolveInnerClasses( - @NotNull DeclarationDescriptor owner, - @NotNull ClassPsiDeclarationProvider declarationProvider) - { - return innerClassResolver.resolveInnerClasses(owner, declarationProvider); + public List resolveInnerClasses(@NotNull ClassPsiDeclarationProvider declarationProvider) { + return innerClassResolver.resolveInnerClasses(declarationProvider); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java index 0f91bc0803d14..b582c77dd9d05 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java @@ -46,7 +46,6 @@ 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 ClassDescriptorFromJvmBytecode createClassObjectDescriptor( return null; } - if (hasInnerEnums(containing, psiClass)) { - return createSyntheticClassObject(containing, psiClass); - } - PsiClass classObjectPsiClass = getClassObjectPsiClass(psiClass); if (classObjectPsiClass == null) { return null; @@ -115,15 +110,6 @@ private ClassDescriptorFromJvmBytecode createClassObjectFromPsi( 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, diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 4177c1a43e71b..29d45c10b1367 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -353,13 +353,6 @@ private ClassOrNamespaceDescriptor resolveParentClass(@NotNull PsiClass psiClass 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; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java index 34a9e086cd650..d3dcfb7b489b4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java @@ -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.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 void setClassResolver(JavaClassResolver classResolver) { } @NotNull - public List resolveInnerClasses( - @NotNull DeclarationDescriptor owner, - @NotNull ClassPsiDeclarationProvider declarationProvider - ) { - if (declarationProvider.isStaticMembers() && declarationProvider.getDeclarationOrigin() == KOTLIN) { - return resolveInnerClassesOfClassObject(owner, declarationProvider.getPsiClass()); + public List resolveInnerClasses(@NotNull ClassPsiDeclarationProvider declarationProvider) { + if (declarationProvider.isStaticMembers()) { + return Collections.emptyList(); } - return resolveInnerClasses(owner, declarationProvider.getPsiClass(), declarationProvider.isStaticMembers()); + return resolveInnerClasses(declarationProvider.getPsiClass()); } @NotNull - private List resolveInnerClasses(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass, boolean isStatic) { + private List resolveInnerClasses(@NotNull PsiClass psiClass) { PsiClass[] innerPsiClasses = psiClass.getInnerClasses(); List result = new ArrayList(innerPsiClasses.length); for (PsiClass innerPsiClass : innerPsiClasses) { - if (shouldBeIgnored(owner, psiClass, innerPsiClass, isStatic)) { + if (shouldBeIgnored(innerPsiClass)) { continue; } ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass); @@ -74,36 +64,8 @@ private List resolveInnerClasses(@NotNull DeclarationDescriptor 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 resolveInnerClassesOfClassObject(@NotNull DeclarationDescriptor classObject, @NotNull PsiClass psiClass) { - if (!DescriptorUtils.isClassObject(classObject)) { - return Collections.emptyList(); - } - - List 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 diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java index 95aa2f394948c..9684aa2fdcf97 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java @@ -71,7 +71,7 @@ private Map getInnerClassesMap() { @NotNull @Override protected Collection computeInnerClasses() { - return getResolver().resolveInnerClasses(descriptor, declarationProvider); + return getResolver().resolveInnerClasses(declarationProvider); } @Override diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java index df626ac40ad1d..cf4e97748787d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java @@ -51,6 +51,6 @@ protected Set computeFunctionDescriptor(@NotNull Name name) @NotNull @Override protected Collection computeInnerClasses() { - return getResolver().resolveInnerClasses(descriptor, declarationProvider); + return getResolver().resolveInnerClasses(declarationProvider); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index 0712f3dfadbc8..13f3a2bfe1439 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -160,8 +160,6 @@ public interface Errors { // Enum-specific - SimpleDiagnosticFactory ENUM_NOT_ALLOWED = SimpleDiagnosticFactory.create(ERROR); - SimpleDiagnosticFactory ILLEGAL_ENUM_ANNOTATION = SimpleDiagnosticFactory .create(ERROR, modifierSetPosition(JetTokens.ENUM_KEYWORD)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java index 7af3705ba19c3..5c0b642daa289 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java @@ -162,7 +162,6 @@ public String render(@NotNull Collection tokens) { 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); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java index 8df63913afa31..b0221e0becf8e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -228,8 +228,6 @@ public Boolean computeValue(SlicedMap map, JetFunctionLiteralExpression expressi ReadOnlySlice DECLARATION_TO_DESCRIPTOR = Slices.sliceBuilder() .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS).build(); - WritableSlice IS_ENUM_MOVED_TO_CLASS_OBJECT = Slices.createSimpleSlice(); - WritableSlice LABEL_TARGET = Slices.sliceBuilder().build(); WritableSlice> AMBIGUOUS_LABEL_TARGET = Slices.>sliceBuilder().build(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index e05fe5b00fa9c..b3ec0e8a5a017 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -196,8 +196,6 @@ private Collection collectNamespacesAndClassifiers( declaration.accept(collector); } - collector.finishProcessing(); - return forDeferredResolve; } @@ -470,8 +468,6 @@ private class ClassifierCollector extends JetVisitorVoid { private final NamespaceLikeBuilder owner; private final Collection forDeferredResolve; - private final List enumsToAddLater = new ArrayList(0); - public ClassifierCollector(@NotNull JetScope outerScope, @NotNull NamespaceLikeBuilder owner, @NotNull Collection forDeferredResolve @@ -501,25 +497,11 @@ public void visitJetFile(JetFile file) { @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 @@ private void prepareForDeferredCall( 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(); - } } } diff --git a/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt b/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt index 905f6e5f0df82..70be742354aad 100644 --- a/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt +++ b/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt @@ -1,6 +1,6 @@ class A { - class B { - enum class E { + inner class B { + enum class E { ENTRY } } diff --git a/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt b/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt index 85e3e3708f3a9..491f81b635942 100644 --- a/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt +++ b/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt @@ -3,7 +3,7 @@ class A { enum class E { ENTRY } // OK } - class B { - enum class E { ENTRY } + inner class B { + enum class E { ENTRY } } } diff --git a/compiler/testData/javaDescriptorResolver/staticMembers/Enum_non_static.txt b/compiler/testData/javaDescriptorResolver/staticMembers/Enum_non_static.txt index e951197ad8d4f..9c9e4d3e4e19d 100644 --- a/compiler/testData/javaDescriptorResolver/staticMembers/Enum_non_static.txt +++ b/compiler/testData/javaDescriptorResolver/staticMembers/Enum_non_static.txt @@ -12,15 +12,15 @@ public final enum class Enum : jet.Enum { public final val C : test.Enum public final fun valueOf(/*0*/ value : jet.String) : test.Enum public final fun values() : jet.Array - - 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 + } } diff --git a/compiler/testData/loadKotlinCustom/enum/innerEnumBinary.txt b/compiler/testData/loadKotlinCustom/enum/innerEnumBinary.txt index 8bcabe4bd07f1..c0e7faa55d169 100644 --- a/compiler/testData/loadKotlinCustom/enum/innerEnumBinary.txt +++ b/compiler/testData/loadKotlinCustom/enum/innerEnumBinary.txt @@ -3,20 +3,16 @@ package test internal final class A { public constructor A() - internal class object { - private constructor () + internal final enum class E : jet.Enum { + 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 { - 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 { - private constructor () - public final val ENTRY : test.A.E - public final fun valueOf(/*0*/ value : jet.String) : test.A.E - public final fun values() : jet.Array - } + internal class object { + private constructor () + public final val ENTRY : test.A.E + public final fun valueOf(/*0*/ value : jet.String) : test.A.E + public final fun values() : jet.Array } } } diff --git a/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectBinary.txt b/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectBinary.txt index 8bcabe4bd07f1..a956d6823f3d4 100644 --- a/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectBinary.txt +++ b/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectBinary.txt @@ -5,18 +5,18 @@ internal final class A { internal class object { private constructor () + } + + internal final enum class E : jet.Enum { + 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 { - 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 { - private constructor () - public final val ENTRY : test.A.E - public final fun valueOf(/*0*/ value : jet.String) : test.A.E - public final fun values() : jet.Array - } + internal class object { + private constructor () + public final val ENTRY : test.A.E + public final fun valueOf(/*0*/ value : jet.String) : test.A.E + public final fun values() : jet.Array } } } diff --git a/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectSource.txt b/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectSource.txt index 93d82e05870da..f6f02e6107ea6 100644 --- a/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectSource.txt +++ b/compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectSource.txt @@ -5,23 +5,23 @@ internal final class A { internal class object { /*primary*/ private constructor () + } + + internal final enum class E : jet.Enum { + /*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 { - /*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 { + /*primary*/ private constructor () + public final val ENTRY : test.A.E + public final fun valueOf(/*0*/ value : jet.String) : test.A.E + public final fun values() : jet.Array - internal class object { - /*primary*/ private constructor () - public final val ENTRY : test.A.E - public final fun valueOf(/*0*/ value : jet.String) : test.A.E - public final fun values() : jet.Array - - 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 } } } diff --git a/compiler/testData/loadKotlinCustom/enum/innerEnumSource.txt b/compiler/testData/loadKotlinCustom/enum/innerEnumSource.txt index d8a30d650964e..940e73b91a811 100644 --- a/compiler/testData/loadKotlinCustom/enum/innerEnumSource.txt +++ b/compiler/testData/loadKotlinCustom/enum/innerEnumSource.txt @@ -3,25 +3,21 @@ package test internal final class A { /*primary*/ public constructor A() - public class object { - /*primary*/ private constructor () + internal final enum class E : jet.Enum { + /*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 { - /*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 { + /*primary*/ private constructor () + public final val ENTRY : test.A.E + public final fun valueOf(/*0*/ value : jet.String) : test.A.E + public final fun values() : jet.Array - internal class object { - /*primary*/ private constructor () - public final val ENTRY : test.A.E - public final fun valueOf(/*0*/ value : jet.String) : test.A.E - public final fun values() : jet.Array - - 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 } } }