Add compile-time errors for enums.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 1100 matching lines @@
     if (mixin == null) return;
 
     // Check that we're not trying to use Object as a mixin.
     if (mixin.superclass == null) {
       compiler.reportError(mixinApplication,
                                MessageKind.ILLEGAL_MIXIN_OBJECT);
       // Avoid reporting additional errors for the Object class.
       return;
     }
 
+    if (mixin.isEnumClass) {
+      // Mixing in an enum has already caused a compile-time error.
+      return;
+    }
+
     // Check that the mixed in class has Object as its superclass.
     if (!mixin.superclass.isObject) {
       compiler.reportError(mixin, MessageKind.ILLEGAL_MIXIN_SUPERCLASS);
     }
 
     // Check that the mixed in class doesn't have any constructors and
     // make sure we aren't mixing in methods that use 'super'.
     mixin.forEachLocalMember((AstElement member) {
       if (member.isGenerativeConstructor && !member.isSynthesized) {
         compiler.reportError(member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
@@ skipping 2232 matching lines @@
     }
     constructor.computeSignature(compiler);
     if (!callSelector.applies(constructor, compiler.world)) {
       registry.registerThrowNoSuchMethod();
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     registry.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.enclosingClass;
+    if (cls.isEnumClass && currentClass != cls) {
+      compiler.reportError(node,
+                           MessageKind.CANNOT_INSTANTIATE_ENUM,
+                           {'enumName': cls.name});
+    }
+
     InterfaceType type = registry.getType(node);
     if (node.isConst && type.containsTypeVariables) {
       compiler.reportError(node.send.selector,
                            MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     // TODO(johniwinther): Avoid registration of `type` in face of redirecting
     // factory constructors.
     registry.registerInstantiatedType(type);
     if (constructor.isFactoryConstructor && !type.typeArguments.isEmpty) {
       registry.registerFactoryWithTypeArguments();
@@ skipping 977 matching lines @@
   DartType checkMixinType(TypeAnnotation mixinNode) {
     DartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
       compiler.reportError(mixinNode,
           MessageKind.CANNOT_MIXIN, {'type': mixinType});
     } else if (mixinType.isTypeVariable) {
       compiler.reportError(mixinNode, MessageKind.CLASS_NAME_EXPECTED);
     } else if (mixinType.isMalformed) {
       compiler.reportError(mixinNode, MessageKind.CANNOT_MIXIN_MALFORMED,
           {'className': element.name, 'malformedType': mixinType});
+    } else if (mixinType.isEnumType) {
+      compiler.reportError(mixinNode, MessageKind.CANNOT_MIXIN_ENUM,
+          {'className': element.name, 'enumType': mixinType});
     }
     return mixinType;
   }
 
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     invariant(node, element != null);
     invariant(element, element.resolutionState == STATE_STARTED,
         message: () => 'cyclic resolution of class $element');
 
     if (identical(node.classKeyword.stringValue, 'typedef')) {
@@ skipping 164 matching lines @@
     return mixinType;
   }
 
   DartType resolveType(TypeAnnotation node) {
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = resolveType(superclass);
     if (supertype != null) {
-      if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
+      if (supertype.isMalformed) {
         compiler.reportError(superclass, MessageKind.CANNOT_EXTEND_MALFORMED,
             {'className': element.name, 'malformedType': supertype});
         return objectType;
-      } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
+      } else if (supertype.isEnumType) {
+        compiler.reportError(superclass, MessageKind.CANNOT_EXTEND_ENUM,
+            {'className': element.name, 'enumType': supertype});
+        return objectType;
+      } else if (!supertype.isInterfaceType) {
         compiler.reportError(superclass.typeName,
             MessageKind.CLASS_NAME_EXPECTED);
         return objectType;
       } else if (isBlackListed(supertype)) {
         compiler.reportError(superclass, MessageKind.CANNOT_EXTEND,
             {'type': supertype});
         return objectType;
       }
     }
     return supertype;
   }
 
   Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
       DartType interfaceType = resolveType(link.head);
       if (interfaceType != null) {
-        if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
+        if (interfaceType.isMalformed) {
           compiler.reportError(superclass,
               MessageKind.CANNOT_IMPLEMENT_MALFORMED,
               {'className': element.name, 'malformedType': interfaceType});
-        } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
+        } else if (interfaceType.isEnumType) {
+          compiler.reportError(superclass,
+              MessageKind.CANNOT_IMPLEMENT_ENUM,
+              {'className': element.name, 'enumType': interfaceType});
+        } else if (!interfaceType.isInterfaceType) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
           error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
             compiler.reportError(
                 superclass,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
             compiler.reportError(
@@ skipping 477 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }