Change when enum constant elements are created to fix bug in re-creating ASTs from existing element…

pkg/analyzer/lib/src/dart/element/builder.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.
 
 library analyzer.src.dart.element.builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 603 matching lines @@
     enumElement.metadata = _createElementAnnotations(node.metadata);
     enumElement.enum2 = true;
     setElementDocumentationComment(enumElement, node);
     InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
     enumElement.type = enumType;
     // The equivalent code for enums in the spec shows a single constructor,
     // but that constructor is not callable (since it is a compile-time error
     // to subclass, mix-in, implement, or explicitly instantiate an enum).  So
     // we represent this as having no constructors.
     enumElement.constructors = ConstructorElement.EMPTY_LIST;
+    //
+    // Build the elements for the constants. These are minimal elements; the
+    // rest of the constant elements (and elements for other fields) must be
+    // built later after we can access the type provider.
+    //
+    List<FieldElement> fields = new List<FieldElement>();
+    NodeList<EnumConstantDeclaration> constants = node.constants;
+    for (EnumConstantDeclaration constant in constants) {
+      SimpleIdentifier constantName = constant.name;
+      FieldElementImpl constantField =
+          new ConstFieldElementImpl.forNode(constantName);
+      constantField.static = true;
+      constantField.const3 = true;
+      constantField.type = enumType;
+      setElementDocumentationComment(constantField, constant);
+      fields.add(constantField);
+      _createGetter(constantField);
+      constantName.staticElement = constantField;
+    }
+    enumElement.fields = fields;
+
     _currentHolder.addEnum(enumElement);
     enumName.staticElement = enumElement;
     return super.visitEnumDeclaration(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     List<ElementAnnotation> annotations =
         _createElementAnnotations(node.metadata);
     compilationUnitElement.setAnnotations(node.offset, annotations);
@@ skipping 675 matching lines @@
     }
     return annotations.map((Annotation a) {
       ElementAnnotationImpl elementAnnotation =
           new ElementAnnotationImpl(compilationUnitElement);
       a.elementAnnotation = elementAnnotation;
       return elementAnnotation;
     }).toList();
   }
 
   /**
+   * Create a getter that corresponds to the given [field].
+   */
+  void _createGetter(FieldElementImpl field) {
+    PropertyAccessorElementImpl getter =
+        new PropertyAccessorElementImpl.forVariable(field);
+    getter.getter = true;
+    getter.returnType = field.type;
+    getter.type = new FunctionTypeImpl(getter);
+    field.getter = getter;
+  }
+
+  /**
    * Create the types associated with the given type parameters, setting the type of each type
    * parameter, and return an array of types corresponding to the given parameters.
    *
    * @param typeParameters the type parameters for which types are to be created
    * @return an array of types corresponding to the given parameters
    */
   List<DartType> _createTypeParameterTypes(
       List<TypeParameterElement> typeParameters) {
     int typeParameterCount = typeParameters.length;
     List<DartType> typeArguments = new List<DartType>(typeParameterCount);
@@ skipping 127 matching lines @@
     return null;
   }
 
   /**
    * Return the lexical identifiers associated with the given [identifiers].
    */
   static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
     return identifiers.map((identifier) => identifier.name).toList();
   }
 }