Support enums in dart2js.

tests/compiler/dart2js/resolver_test.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.
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import "package:async_helper/async_helper.dart";
 import 'dart:collection';
 
 import "package:compiler/src/resolution/resolution.dart";
@@ skipping 58 matching lines @@
     testFor,
     testTypeAnnotation,
     testSuperclass,
     // testVarSuperclass, // The parser crashes with 'class Foo extends var'.
     // testOneInterface, // Generates unexpected error message.
     // testTwoInterfaces, // Generates unexpected error message.
     testFunctionExpression,
     testNewExpression,
     testTopLevelFields,
     testClassHierarchy,
+    testEnumDeclaration,
     testInitializers,
     testThis,
     testSuperCalls,
     testSwitch,
     testTypeVariables,
     testToString,
     testIndexedOperator,
     testIncrementsAndDecrements,
     testOverrideHashCodeCheck,
     testSupertypeOrder,
@@ skipping 710 matching lines @@
       compiler.resolver.resolve(mainElement);
       Expect.equals(0, compiler.warnings.length);
       Expect.equals(1, compiler.errors.length);
       Expect.equals(MessageKind.MULTI_INHERITANCE,
                     compiler.errors[0].message.kind);
       Expect.equals(0, compiler.crashes.length);
     }),
   ]);
 }
 
+Future testEnumDeclaration() {
+  final MAIN = "main";
+  return Future.wait([
+    MockCompiler.create((MockCompiler compiler) {
+      compiler.parseScript("""enum Enum {}
+                              main() { Enum e; }""");
+      FunctionElement mainElement = compiler.mainApp.find(MAIN);
+      compiler.resolver.resolve(mainElement);
+      Expect.equals(0, compiler.warnings.length,
+                    'Unexpected warnings: ${compiler.warnings}');
+      Expect.equals(0, compiler.errors.length,
+                    'Unexpected errors: ${compiler.errors}');
+    }, enableEnums: true),
+    MockCompiler.create((MockCompiler compiler) {
+      compiler.parseScript("""enum Enum {}
+                              main() { Enum e = Enum.A; }""");
+      FunctionElement mainElement = compiler.mainApp.find(MAIN);
+      compiler.resolver.resolve(mainElement);
+      Expect.equals(1, compiler.warnings.length,
+                    'Unexpected warnings: ${compiler.warnings}');
+      Expect.equals(MessageKind.MEMBER_NOT_FOUND,
+                    compiler.warnings[0].message.kind);
+      Expect.equals(0, compiler.errors.length,
+                    'Unexpected errors: ${compiler.errors}');
+    }, enableEnums: true),
+    MockCompiler.create((MockCompiler compiler) {
+      compiler.parseScript("""enum Enum { A }
+                              main() { Enum e = Enum.A; }""");
+      FunctionElement mainElement = compiler.mainApp.find(MAIN);
+      compiler.resolver.resolve(mainElement);
+      Expect.equals(0, compiler.warnings.length,
+                    'Unexpected warnings: ${compiler.warnings}');
+      Expect.equals(0, compiler.errors.length,
+                    'Unexpected errors: ${compiler.errors}');
+    }, enableEnums: true),
+    MockCompiler.create((MockCompiler compiler) {
+      compiler.parseScript("""enum Enum { A }
+                              main() { Enum e = Enum.B; }""");
+      FunctionElement mainElement = compiler.mainApp.find(MAIN);
+      compiler.resolver.resolve(mainElement);
+      Expect.equals(1, compiler.warnings.length,
+                    'Unexpected warnings: ${compiler.warnings}');
+      Expect.equals(MessageKind.MEMBER_NOT_FOUND,
+                    compiler.warnings[0].message.kind);
+      Expect.equals(0, compiler.errors.length,
+                    'Unexpected errors: ${compiler.errors}');
+    }, enableEnums: true),
+    MockCompiler.create((MockCompiler compiler) {
+      compiler.parseScript("""enum Enum { A }
+                              main() { List values = Enum.values; }""");
+      FunctionElement mainElement = compiler.mainApp.find(MAIN);
+      compiler.resolver.resolve(mainElement);
+      Expect.equals(0, compiler.warnings.length,
+                    'Unexpected warnings: ${compiler.warnings}');
+      Expect.equals(0, compiler.errors.length,
+                    'Unexpected errors: ${compiler.errors}');
+    }, enableEnums: true),
+  ]);
+}
+
 Future testInitializers() {
   return Future.forEach([
     () {
       String script =
           """class A {
                     int foo; int bar;
                     A() : this.foo = 1, bar = 2;
                   }""";
       return resolveConstructor(script, "A a = new A();", "A", "", 2);
     },
@@ skipping 245 matching lines @@
       }""";
   asyncTest(() => compileScript(script2).then((compiler) {
     expect(compiler,
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS],
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD]);
   }));
 }