KT-2714 'enum' annotation should only be allowed on classes

#KT-2714 Fixed

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java

@@ -70,6 +70,8 @@ public interface Errors {
             .create(WARNING, positionModifier(JetTokens.OPEN_KEYWORD));
     SimpleDiagnosticFactory<JetModifierListOwner> OPEN_MODIFIER_IN_ENUM = SimpleDiagnosticFactory
             .create(ERROR, positionModifier(JetTokens.OPEN_KEYWORD));
+    SimpleDiagnosticFactory<JetModifierListOwner> ILLEGAL_ENUM_ANNOTATION = SimpleDiagnosticFactory
+            .create(ERROR, positionModifier(JetTokens.ENUM_KEYWORD));
     SimpleDiagnosticFactory<PsiElement>
             REDUNDANT_MODIFIER_IN_GETTER = SimpleDiagnosticFactory.create(WARNING);
     SimpleDiagnosticFactory<PsiElement> TRAIT_CAN_NOT_BE_FINAL = SimpleDiagnosticFactory.create(ERROR);

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java

@@ -82,6 +82,7 @@ public class DefaultErrorMessages {
         MAP.put(ABSTRACT_MODIFIER_IN_TRAIT, "Modifier ''abstract'' is redundant in trait");
         MAP.put(OPEN_MODIFIER_IN_TRAIT, "Modifier ''open'' is redundant in trait");
         MAP.put(OPEN_MODIFIER_IN_ENUM, "Modifier ''open'' is not applicable for enum class");
+        MAP.put(ILLEGAL_ENUM_ANNOTATION, "Annotation ''enum'' is only applicable for class");
         MAP.put(REDUNDANT_MODIFIER_IN_GETTER, "Visibility modifiers are redundant in getter");
         MAP.put(TRAIT_CAN_NOT_BE_FINAL, "Trait cannot be final");
         MAP.put(TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM,

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

@@ -66,6 +66,7 @@ public class DeclarationsChecker {
             MutableClassDescriptor objectDescriptor = entry.getValue();
 
             if (!bodiesResolveContext.completeAnalysisNeeded(objectDeclaration)) continue;
+            checkObject(objectDeclaration);
             modifiersChecker.checkIllegalModalityModifiers(objectDeclaration);
         }
 
@@ -91,12 +92,22 @@ public class DeclarationsChecker {
 
     }
 
+    private void reportErrorIfHasEnumModifier(JetModifierListOwner declaration) {
+        if (declaration.hasModifier(JetTokens.ENUM_KEYWORD)) {
+            trace.report(ILLEGAL_ENUM_ANNOTATION.on(declaration));
+        }
+    }
+    
+    private void checkObject(JetObjectDeclaration declaration) {
+        reportErrorIfHasEnumModifier(declaration);
+    }
+
     private void checkClass(JetClass aClass, MutableClassDescriptor classDescriptor) {
         checkOpenMembers(classDescriptor);
         if (aClass.isTrait()) {
             checkTraitModifiers(aClass);
         }
-        else if (aClass.hasModifier(JetTokens.ENUM_KEYWORD)) {
+        else if (classDescriptor.getKind() == ClassKind.ENUM_CLASS) {
             checkEnumModifiers(aClass);
         }
         else if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY) {
@@ -105,6 +116,7 @@ public class DeclarationsChecker {
     }
 
     private void checkTraitModifiers(JetClass aClass) {
+        reportErrorIfHasEnumModifier(aClass);
         JetModifierList modifierList = aClass.getModifierList();
         if (modifierList == null) return;
         if (modifierList.hasModifier(JetTokens.FINAL_KEYWORD)) {
@@ -130,6 +142,7 @@ public class DeclarationsChecker {
     }
 
     private void checkProperty(JetProperty property, PropertyDescriptor propertyDescriptor) {
+        reportErrorIfHasEnumModifier(property);
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
         if (containingDeclaration instanceof ClassDescriptor) {
             checkPropertyAbstractness(property, propertyDescriptor, (ClassDescriptor) containingDeclaration);
@@ -247,6 +260,7 @@ public class DeclarationsChecker {
     }
 
     protected void checkFunction(JetNamedFunction function, SimpleFunctionDescriptor functionDescriptor) {
+        reportErrorIfHasEnumModifier(function);
         DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration();
         boolean hasAbstractModifier = function.hasModifier(JetTokens.ABSTRACT_KEYWORD);
         checkDeclaredTypeInPublicMember(function, functionDescriptor);

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

@@ -279,7 +279,7 @@ public class TypeHierarchyResolver {
                 }
 
                 private void createClassObjectForEnumClass(JetClass klass, MutableClassDescriptor mutableClassDescriptor) {
-                    if (klass.hasModifier(JetTokens.ENUM_KEYWORD)) {
+                    if (mutableClassDescriptor.getKind() == ClassKind.ENUM_CLASS) {
                         MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(
                                 mutableClassDescriptor, outerScope, ClassKind.CLASS_OBJECT,
                                 getClassObjectName(klass.getName()));

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

@@ -0,0 +1,15 @@
+enum class B {}
+
+class A {
+   <!ILLEGAL_ENUM_ANNOTATION!>enum<!> class object {}
+}
+
+<!ILLEGAL_ENUM_ANNOTATION!>enum<!> object O {}
+
+<!ILLEGAL_ENUM_ANNOTATION!>enum<!> trait T {}
+
+<!ILLEGAL_ENUM_ANNOTATION!>enum<!> fun f() = 0
+
+<!ILLEGAL_ENUM_ANNOTATION!>enum<!> val x = 0
+
+<!ILLEGAL_ENUM_ANNOTATION!>enum<!> var y = 0

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

@@ -1367,6 +1367,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 doTest("compiler/testData/diagnostics/tests/enum/enumInheritance.kt");
             }
             
+            @TestMetadata("enumModifier.kt")
+            public void testEnumModifier() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/enum/enumModifier.kt");
+            }
+            
             @TestMetadata("enumStarImport.kt")
             public void testEnumStarImport() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/enum/enumStarImport.kt");