Support enums in dart2dart.

pkg/compiler/lib/src/dart_backend/outputter.dart

 // Copyright (c) 2014, 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 dart_backend;
 
 typedef bool IsSafeToRemoveTypeDeclarations(
     Map<ClassElement, Iterable<Element>> classMembers);
 typedef void ElementCallback<E>(E element);
 typedef void ElementPostProcessFunction(
@@ skipping 78 matching lines @@
 
     if (sortElements == null) {
       // Ensure deterministic output order.
       sortElements = (Iterable<Element> elements) {
         List<Element> list = elements.toList();
         list.sort((Element a, Element b) => a.name.compareTo(b.name));
         return list;
       };
     }
 
-    libraryInfo = LibraryInfo.processLibraries(libraries, resolvedElements);
+    libraryInfo = LibraryInfo.processLibraries(
+        listener, libraries, resolvedElements);
 
     elementInfo = ElementInfoProcessor.createElementInfo(
         instantiatedClasses,
         resolvedElements,
         usedTypeLiterals,
         postProcessElementAst: postProcessElementAst,
         parseElementAst: computeElementAst,
         shouldOutput: shouldOutput,
         sortElements: sortElements);
 
@@ skipping 45 matching lines @@
     PlaceholderCollector collector = new PlaceholderCollector(
         listener,
         mirrorRenamer,
         libraryInfo.fixedDynamicNames,
         elementInfo.elementAsts,
         mainFunction);
 
     makePlaceholders(element) {
       collector.collect(element);
 
-      if (element.isClass) {
+      if (element.isClass && !element.isEnumClass) {
         elementInfo.classMembers[element].forEach(makePlaceholders);
       }
     }
     elementInfo.topLevelElements.forEach(makePlaceholders);
     return collector;
   }
 
   static PlaceholderRenamer createRenamer(
       PlaceholderCollector collector,
       LibraryInfo libraryInfo,
@@ skipping 45 matching lines @@
   final Set<String> fixedDynamicNames;
   final Map<Element, LibraryElement> reexportingLibraries;
   final List<LibraryElement> userLibraries;
 
   LibraryInfo(this.fixedStaticNames,
               this.fixedDynamicNames,
               this.reexportingLibraries,
               this.userLibraries);
 
   static LibraryInfo processLibraries(
+      DiagnosticListener listener,
       Iterable<LibraryElement> libraries,
       Iterable<AstElement> resolvedElements) {
     Set<String> fixedStaticNames = new Set<String>();
     Set<String> fixedDynamicNames = new Set<String>();
     Map<Element, LibraryElement> reexportingLibraries =
           <Element, LibraryElement>{};
     List<LibraryElement> userLibraries = <LibraryElement>[];
     // Conservatively traverse all platform libraries and collect member names.
     // TODO(antonm): ideally we should only collect names of used members,
     // however as of today there are problems with names of some core library
@@ skipping 28 matching lines @@
         if (!library.isInternalLibrary &&
             export.library.isInternalLibrary) {
           // If an element of an internal library is reexported by a platform
           // library, we have to import the reexporting library instead of the
           // internal library, because the internal library is an
           // implementation detail of dart2js.
           reexportingLibraries[export] = library;
         }
       }
     }
+
+    // Map to keep track of names of enum classes. Since these cannot be renamed
+    // we ensure that they are unique.
+    Map<String, ClassElement> enumClassMap = <String, ClassElement>{};
+
     // As of now names of named optionals are not renamed. Therefore add all
     // field names used as named optionals into [fixedMemberNames].
     for (final element in resolvedElements) {
       if (!element.isConstructor) continue;
       Link<Element> optionalParameters =
           element.functionSignature.optionalParameters;
       for (final optional in optionalParameters) {
         if (!optional.isInitializingFormal) continue;
         fixedDynamicNames.add(optional.name);
       }
+      ClassElement cls = element.enclosingClass;
+      if (cls != null && cls.isEnumClass) {
+        fixedDynamicNames.add('index');
+
+        ClassElement existingEnumClass =
+            enumClassMap.putIfAbsent(cls.name, () => cls);
+        if (existingEnumClass != cls) {
+          listener.reportError(cls, MessageKind.GENERIC,
+              {'text': "Duplicate enum names are not supported in dart2dart."});
+          listener.reportInfo(existingEnumClass, MessageKind.GENERIC,
+              {'text': "This is the other declaration of '${cls.name}'."});
+        }
+      }
     }
+
+    fixedStaticNames.addAll(enumClassMap.keys);
+
     // The VM will automatically invoke the call method of objects
     // that are invoked as functions. Make sure to not rename that.
     fixedDynamicNames.add('call');
 
     return new LibraryInfo(
         fixedStaticNames, fixedDynamicNames,
         reexportingLibraries, userLibraries);
   }
 }
 
@@ skipping 102 matching lines @@
     Node node = treePrinter.makeTypedef(element);
     addTopLevel(element, new ElementAst(node, treeElements));
   }
 
   void newClassElementCallback(ClassElement classElement) {
     if (!shouldOutput(classElement)) return;
     addClass(classElement);
   }
 
   void addMember(element) {
-    ElementAst elementAst = parseElementAst(element);
     if (element.isClassMember) {
       ClassElement enclosingClass = element.enclosingClass;
       assert(enclosingClass.isClass);
       assert(enclosingClass.isTopLevel);
       assert(shouldOutput(enclosingClass));
       addClass(enclosingClass);
       classMembers[enclosingClass].add(element);
-      processElement(element, elementAst);
+      if (enclosingClass.isEnumClass) return;
+      processElement(element, parseElementAst(element));
     } else {
       if (element.isTopLevel) {
-        addTopLevel(element, elementAst);
+        addTopLevel(element, parseElementAst(element));
       }
     }
   }
 }
 
 /// Main output generator for [DartOutputter] that emits dart code through a
 /// [CompilerOutputProvider].
 class MainOutputGenerator {
   final Map<ClassNode, List<Node>> memberNodes =
        new Map<ClassNode, List<Node>>();
   final List<Node> topLevelNodes = <Node>[];
 
   /// Generates the code and returns the total size.
   int generateCode(
       LibraryInfo libraryInfo,
       ElementInfo elementInfo,
       PlaceholderCollector collector,
       PlaceholderRenamer placeholderRenamer,
       FunctionElement mainFunction,
       Uri outputUri,
       CompilerOutputProvider outputProvider,
       MirrorRenamer mirrorRenamer,
       {bool multiFile: false,
        bool forceStripTypes: false,
        bool enableMinification: false}) {
     for (Element element in elementInfo.topLevelElements) {
       topLevelNodes.add(elementInfo.elementAsts[element].ast);
-      if (element.isClass && !element.isMixinApplication) {
+      if (element.isClass) {
+        ClassElement cls = element;
+        if (cls.isMixinApplication || cls.isEnumClass) {
+          continue;
+        }
         final members = <Node>[];
-        for (Element member in elementInfo.classMembers[element]) {
+        for (Element member in elementInfo.classMembers[cls]) {
           members.add(elementInfo.elementAsts[member].ast);
         }
-        memberNodes[elementInfo.elementAsts[element].ast] = members;
+        memberNodes[elementInfo.elementAsts[cls].ast] = members;
       }
     }
 
     mirrorRenamer.addRenames(placeholderRenamer.renames,
                              topLevelNodes, collector);
 
     Map<LibraryElement, String> outputPaths = new Map<LibraryElement, String>();
     Map<LibraryElement, EmitterUnparser> unparsers =
         new Map<LibraryElement, EmitterUnparser>();
 
@@ skipping 97 matching lines @@
       outputProvider("", "dart")
            ..add(code)
            ..close();
 
       totalSize = code.length;
     }
 
     return totalSize;
   }
 }