Synthetic class object of enum should always be public

#KT-2834 Fixed

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.resolve.DescriptorFactory;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.InnerClassesScopeWrapper;
@@ -270,20 +271,15 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         MutableClassDescriptor classObject = new MutableClassDescriptor(this, getScopeForMemberLookup(), ClassKind.CLASS_OBJECT,
                                                                         false, getClassObjectName(getName()));
         classObject.setModality(Modality.FINAL);
-        classObject.setVisibility(getVisibility());
+        classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility());
         classObject.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
+        classObject.setPrimaryConstructor(DescriptorFactory.createPrimaryConstructorForObject(classObject));
         classObject.createTypeConstructor();
 
-        ConstructorDescriptorImpl primaryConstructor = DescriptorFactory.createPrimaryConstructorForObject(classObject);
-        primaryConstructor.setReturnType(classObject.getDefaultType());
-        classObject.setPrimaryConstructor(primaryConstructor);
-
-        JetType defaultType = getDefaultType();
-        JetType defaultTypeArray = KotlinBuiltIns.getInstance().getArrayType(defaultType);
-        classObject.getBuilder().addFunctionDescriptor(
-                DescriptorFactory.createEnumClassObjectValuesMethod(classObject, defaultTypeArray));
-        classObject.getBuilder().addFunctionDescriptor(
-                DescriptorFactory.createEnumClassObjectValueOfMethod(classObject, defaultType));
+        JetType enumType = getDefaultType();
+        JetType enumArrayType = KotlinBuiltIns.getInstance().getArrayType(enumType);
+        classObject.getBuilder().addFunctionDescriptor(DescriptorFactory.createEnumClassObjectValuesMethod(classObject, enumArrayType));
+        classObject.getBuilder().addFunctionDescriptor(DescriptorFactory.createEnumClassObjectValueOfMethod(classObject, enumType));
 
         return classObject;
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java

@@ -1285,7 +1285,7 @@ public class DescriptorResolver {
                 classDescriptor,
                 valueParameter.getAnnotations(),
                 resolveModalityFromModifiers(parameter, Modality.FINAL),
-                resolveVisibilityFromModifiers(parameter),
+                resolveVisibilityFromModifiers(parameter, Visibilities.INTERNAL),
                 isMutable,
                 name,
                 CallableMemberDescriptor.Kind.DECLARATION

compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java

@@ -212,11 +212,6 @@ public class ModifiersChecker {
         return defaultModality;
     }
 
-    @NotNull
-    public static Visibility resolveVisibilityFromModifiers(@NotNull JetModifierListOwner modifierListOwner) {
-        return resolveVisibilityFromModifiers(modifierListOwner, Visibilities.INTERNAL);
-    }
-
     @NotNull
     public static Visibility resolveVisibilityFromModifiers(@NotNull JetModifierListOwner modifierListOwner, @NotNull Visibility defaultVisibility) {
         return resolveVisibilityFromModifiers(modifierListOwner.getModifierList(), defaultVisibility);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java

@@ -513,32 +513,25 @@ public class TypeHierarchyResolver {
             }
         }
 
-        private void createClassObjectForEnumClass(JetClass klass, MutableClassDescriptor mutableClassDescriptor) {
+        private void createClassObjectForEnumClass(@NotNull MutableClassDescriptor mutableClassDescriptor) {
             if (mutableClassDescriptor.getKind() == ClassKind.ENUM_CLASS) {
-                MutableClassDescriptor classObjectDescriptor =
-                        createClassObjectDescriptor(mutableClassDescriptor, resolveVisibilityFromModifiers(klass));
-                mutableClassDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor);
-                classObjectDescriptor.getBuilder().addFunctionDescriptor(
-                        DescriptorResolver.createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
-                classObjectDescriptor.getBuilder().addFunctionDescriptor(
-                        DescriptorResolver.createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
+                MutableClassDescriptor classObject = createSyntheticClassObject(mutableClassDescriptor);
+                mutableClassDescriptor.getBuilder().setClassObjectDescriptor(classObject);
+                classObject.getBuilder().addFunctionDescriptor(DescriptorResolver.createEnumClassObjectValuesMethod(classObject, trace));
+                classObject.getBuilder().addFunctionDescriptor(DescriptorResolver.createEnumClassObjectValueOfMethod(classObject, trace));
             }
         }
 
         @NotNull
-        private MutableClassDescriptor createClassObjectDescriptor(
-                @NotNull ClassDescriptor classDescriptor,
-                @NotNull Visibility visibility
-        ) {
-            MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(
-                    classDescriptor, outerScope, ClassKind.CLASS_OBJECT, false, getClassObjectName(classDescriptor.getName()));
-            classObjectDescriptor.setModality(Modality.FINAL);
-            classObjectDescriptor.setVisibility(visibility);
-            classObjectDescriptor.setTypeParameterDescriptors(new ArrayList<TypeParameterDescriptor>(0));
-            classObjectDescriptor.createTypeConstructor();
-            ConstructorDescriptorImpl primaryConstructorForObject = createPrimaryConstructorForObject(null, classObjectDescriptor);
-            primaryConstructorForObject.setReturnType(classObjectDescriptor.getDefaultType());
-            return classObjectDescriptor;
+        private MutableClassDescriptor createSyntheticClassObject(@NotNull ClassDescriptor classDescriptor) {
+            MutableClassDescriptor classObject = new MutableClassDescriptor(classDescriptor, outerScope, ClassKind.CLASS_OBJECT, false,
+                                                                            getClassObjectName(classDescriptor.getName()));
+            classObject.setModality(Modality.FINAL);
+            classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility());
+            classObject.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
+            createPrimaryConstructorForObject(null, classObject);
+            classObject.createTypeConstructor();
+            return classObject;
         }
 
         @NotNull
@@ -555,7 +548,7 @@ public class TypeHierarchyResolver {
             context.getClasses().put(klass, mutableClassDescriptor);
             trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(klass), mutableClassDescriptor);
 
-            createClassObjectForEnumClass(klass, mutableClassDescriptor);
+            createClassObjectForEnumClass(mutableClassDescriptor);
 
             JetScope classScope = mutableClassDescriptor.getScopeForMemberResolution();
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java

@@ -53,6 +53,7 @@ import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.*;
 
+import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClassObject;
 import static org.jetbrains.jet.lang.resolve.ModifiersChecker.*;
 import static org.jetbrains.jet.lang.resolve.name.SpecialNames.getClassObjectName;
 
@@ -111,8 +112,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
 
         this.typeConstructor = new LazyClassTypeConstructor();
 
-        JetModifierList modifierList = classLikeInfo.getModifierList();
         this.kind = classLikeInfo.getClassKind();
+
+        JetModifierList modifierList = classLikeInfo.getModifierList();
         if (kind.isObject()) {
             this.modality = Modality.FINAL;
         }
@@ -120,7 +122,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
             Modality defaultModality = kind == ClassKind.TRAIT ? Modality.ABSTRACT : Modality.FINAL;
             this.modality = resolveModalityFromModifiers(modifierList, defaultModality);
         }
-        this.visibility = resolveVisibilityFromModifiers(modifierList, getDefaultClassVisibility(this));
+        this.visibility = isEnumClassObject(this)
+                          ? DescriptorUtils.getSyntheticClassObjectVisibility()
+                          : resolveVisibilityFromModifiers(modifierList, getDefaultClassVisibility(this));
         this.isInner = isInnerClass(modifierList);
 
         StorageManager storageManager = resolveSession.getStorageManager();

compiler/testData/diagnostics/tests/enum/kt2834.kt

@@ -0,0 +1,6 @@
+private enum class MethodKind {
+    INSTANCE
+    STATIC
+}
+
+fun MethodKind.hasThis() = this == MethodKind.INSTANCE

compiler/testData/lazyResolve/namespaceComparator/enum.txt

@@ -5,7 +5,7 @@ internal final enum class Test : jet.Enum<test.Test> {
     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-Test> {
+    public class object <class-object-for-Test> {
         /*primary*/ private constructor <class-object-for-Test>()
         public final val A: test.Test
         public final val B: test.Test

compiler/testData/loadKotlin/annotations/parameters/EnumConstructor.txt

@@ -17,7 +17,7 @@ internal final enum class E : jet.Enum<test.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> {
+    public class object <class-object-for-E> {
         /*primary*/ private constructor <class-object-for-E>()
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.E
         public final /*synthesized*/ fun values(): jet.Array<test.E>

compiler/testData/loadKotlin/class/EnumWithGenericConstructorParameter.txt

@@ -5,7 +5,7 @@ internal final enum class EnumWithGenericConstructorParameter : jet.Enum<test.En
     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-EnumWithGenericConstructorParameter> {
+    public class object <class-object-for-EnumWithGenericConstructorParameter> {
         /*primary*/ private constructor <class-object-for-EnumWithGenericConstructorParameter>()
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.EnumWithGenericConstructorParameter
         public final /*synthesized*/ fun values(): jet.Array<test.EnumWithGenericConstructorParameter>

compiler/testData/loadKotlin/class/EnumWithPrimitiveConstructorParameter.txt

@@ -5,7 +5,7 @@ internal final enum class EnumWithPrimitiveConstructorParameter : jet.Enum<test.
     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-EnumWithPrimitiveConstructorParameter> {
+    public class object <class-object-for-EnumWithPrimitiveConstructorParameter> {
         /*primary*/ private constructor <class-object-for-EnumWithPrimitiveConstructorParameter>()
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.EnumWithPrimitiveConstructorParameter
         public final /*synthesized*/ fun values(): jet.Array<test.EnumWithPrimitiveConstructorParameter>

compiler/testData/loadKotlinCustom/enum/enumVisibilityBinary.txt

@@ -5,7 +5,7 @@ internal final enum class In : jet.Enum<test.In> {
     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-In> {
+    public class object <class-object-for-In> {
         private constructor <class-object-for-In>()
         public final val A: test.In
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.In
@@ -18,7 +18,7 @@ private final enum class Pr : jet.Enum<test.Pr> {
     public final override /*1*/ /*fake_override*/ fun name(): jet.String
     public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     
-    private class object <class-object-for-Pr> {
+    public class object <class-object-for-Pr> {
         private constructor <class-object-for-Pr>()
         public final val A: test.Pr
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.Pr

compiler/testData/loadKotlinCustom/enum/enumVisibilitySource.txt

@@ -5,7 +5,7 @@ internal final enum class In : jet.Enum<test.In> {
     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-In> {
+    public class object <class-object-for-In> {
         /*primary*/ private constructor <class-object-for-In>()
         public final val A: test.In
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.In
@@ -24,7 +24,7 @@ private final enum class Pr : jet.Enum<test.Pr> {
     public final override /*1*/ /*fake_override*/ fun name(): jet.String
     public final override /*1*/ /*fake_override*/ fun ordinal(): jet.Int
     
-    private class object <class-object-for-Pr> {
+    public class object <class-object-for-Pr> {
         /*primary*/ private constructor <class-object-for-Pr>()
         public final val A: test.Pr
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.Pr

compiler/testData/loadKotlinCustom/enum/innerEnumBinary.txt

@@ -8,7 +8,7 @@ internal final class A {
         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> {
+        public class object <class-object-for-E> {
             private constructor <class-object-for-E>()
             public final val ENTRY: test.A.E
             public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.A.E

compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectBinary.txt

@@ -12,7 +12,7 @@ internal final class A {
         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> {
+        public class object <class-object-for-E> {
             private constructor <class-object-for-E>()
             public final val ENTRY: test.A.E
             public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.A.E

compiler/testData/loadKotlinCustom/enum/innerEnumExistingClassObjectSource.txt

@@ -12,7 +12,7 @@ internal final class A {
         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> {
+        public class object <class-object-for-E> {
             /*primary*/ private constructor <class-object-for-E>()
             public final val ENTRY: test.A.E
             public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.A.E

compiler/testData/loadKotlinCustom/enum/innerEnumSource.txt

@@ -8,7 +8,7 @@ internal final class A {
         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> {
+        public class object <class-object-for-E> {
             /*primary*/ private constructor <class-object-for-E>()
             public final val ENTRY: test.A.E
             public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.A.E

compiler/testData/loadKotlinCustom/enum/simpleEnumBinary.txt

@@ -5,7 +5,7 @@ internal final enum class MyEnum : jet.Enum<test.MyEnum> {
     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-MyEnum> {
+    public class object <class-object-for-MyEnum> {
         private constructor <class-object-for-MyEnum>()
         public final val ENTRY: test.MyEnum
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.MyEnum

compiler/testData/loadKotlinCustom/enum/simpleEnumSource.txt

@@ -5,7 +5,7 @@ internal final enum class MyEnum : jet.Enum<test.MyEnum> {
     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-MyEnum> {
+    public class object <class-object-for-MyEnum> {
         /*primary*/ private constructor <class-object-for-MyEnum>()
         public final val ENTRY: test.MyEnum
         public final /*synthesized*/ fun valueOf(/*0*/ value: jet.String): test.MyEnum

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -2587,6 +2587,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 doTest("compiler/testData/diagnostics/tests/enum/javaEnumWithProperty.kt");
             }
             
+            @TestMetadata("kt2834.kt")
+            public void testKt2834() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/enum/kt2834.kt");
+            }
+            
             @TestMetadata("compiler/testData/diagnostics/tests/enum/inner")
             public static class Inner extends AbstractDiagnosticsTestWithEagerResolve {
                 public void testAllFilesPresentInInner() throws Exception {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -428,7 +428,7 @@ public final class JavaClassResolver {
         JavaEnumClassObjectDescriptor classObject = new JavaEnumClassObjectDescriptor(enumClass);
 
         classObject.setModality(Modality.FINAL);
-        classObject.setVisibility(enumClass.getVisibility());
+        classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility());
         classObject.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classObject.createTypeConstructor();
 

core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java

@@ -28,7 +28,6 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.name.SpecialNames;
 import org.jetbrains.jet.lang.resolve.scopes.FilteringScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
@@ -328,6 +327,11 @@ public class DescriptorUtils {
         return Visibilities.PUBLIC;
     }
 
+    @NotNull
+    public static Visibility getSyntheticClassObjectVisibility() {
+        return Visibilities.PUBLIC;
+    }
+
     @NotNull
     public static List<String> getSortedValueArguments(
             @NotNull AnnotationDescriptor descriptor,