Resynthesize enum fields lazily.

pkg/analyzer/lib/src/dart/element/element.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.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
+import 'package:analyzer/src/dart/constant/value.dart';
 import 'package:analyzer/src/dart/element/handle.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/constant.dart' show EvaluationResultImpl;
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine;
 import 'package:analyzer/src/generated/error.dart' show CompileTimeErrorCode;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
@@ skipping 1753 matching lines @@
 
   /**
    * Initialize using the given serialized information.
    */
   ConstFieldElementImpl.forSerialized(
       UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
       : super.forSerialized(unlinkedVariable, enclosingElement);
 }
 
 /**
+ * A value field of an enum.

[Brian Wilkerson, 2016/06/06 13:39:50]

This wasn't clear to me; I had to read more code to figure out what this meant.
How about something like "A field element representing an enum constant."?

[scheglov, 2016/06/06 15:31:43]

Done.

+ */
+class ConstFieldElementImpl_EnumValue extends ConstFieldElementImpl_ofEnum {
+  final UnlinkedEnumValue _unlinkedEnumValue;
+  final int _index;
+
+  ConstFieldElementImpl_EnumValue(
+      EnumElementImpl enumElement, this._unlinkedEnumValue, this._index)
+      : super(enumElement);
+
+  @override
+  SourceRange get docRange {
+    if (_unlinkedEnumValue != null) {
+      UnlinkedDocumentationComment comment =
+          _unlinkedEnumValue.documentationComment;
+      return comment != null
+          ? new SourceRange(comment.offset, comment.length)
+          : null;
+    }
+    return super.docRange;
+  }
+
+  @override
+  String get documentationComment {
+    if (_unlinkedEnumValue != null) {
+      return _unlinkedEnumValue?.documentationComment?.text;
+    }
+    return super.documentationComment;
+  }
+
+  @override
+  EvaluationResultImpl get evaluationResult {
+    if (_evaluationResult == null) {
+      Map<String, DartObjectImpl> fieldMap = <String, DartObjectImpl>{
+        name: new DartObjectImpl(
+            context.typeProvider.intType, new IntState(_index))
+      };
+      DartObjectImpl value =
+          new DartObjectImpl(type, new GenericState(fieldMap));
+      _evaluationResult = new EvaluationResultImpl(value);
+    }
+    return _evaluationResult;
+  }
+
+  @override
+  String get name {
+    if (_unlinkedEnumValue != null) {
+      return _unlinkedEnumValue.name;
+    }
+    return super.name;
+  }
+
+  @override
+  int get nameOffset {
+    if (_unlinkedEnumValue != null) {
+      return _unlinkedEnumValue.nameOffset;
+    }
+    return super.nameOffset;
+  }
+
+  @override
+  InterfaceType get type => _enum.type;
+}
+
+/**
+ * The synthetic `values` field of an enum.
+ */
+class ConstFieldElementImpl_EnumValues extends ConstFieldElementImpl_ofEnum {
+  ConstFieldElementImpl_EnumValues(EnumElementImpl enumElement)
+      : super(enumElement) {
+    synthetic = true;
+  }
+
+  @override
+  EvaluationResultImpl get evaluationResult {
+    if (_evaluationResult == null) {
+      List<DartObjectImpl> constantValues = <DartObjectImpl>[];
+      for (FieldElement field in _enum.fields) {
+        if (field is ConstFieldElementImpl_EnumValue) {
+          constantValues.add(field.evaluationResult.value);
+        }
+      }
+      _evaluationResult = new EvaluationResultImpl(
+          new DartObjectImpl(type, new ListState(constantValues)));
+    }
+    return _evaluationResult;
+  }
+
+  @override
+  String get name => 'values';
+
+  @override
+  InterfaceType get type {
+    if (_type == null) {
+      InterfaceType listType = context.typeProvider.listType;
+      return _type = listType.instantiate(<DartType>[_enum.type]);
+    }
+    return _type;
+  }
+}
+
+/**
+ * An abstract constant field of an enum.
+ */
+abstract class ConstFieldElementImpl_ofEnum extends ConstFieldElementImpl {
+  final EnumElementImpl _enum;
+
+  ConstFieldElementImpl_ofEnum(this._enum) : super(null, -1) {
+    enclosingElement = _enum;
+  }
+
+  @override
+  void set const3(bool isConst) {
+    assert(false);
+  }
+
+  @override
+  void set evaluationResult(_) {
+    assert(false);
+  }
+
+  @override
+  void set final2(bool isFinal) {
+    assert(false);
+  }
+
+  @override
+  bool get isConst => true;
+
+  @override
+  bool get isStatic => true;
+
+  @override
+  void set static(bool isStatic) {
+    assert(false);
+  }
+
+  void set type(DartType type) {
+    assert(false);
+  }
+}
+
+/**
  * A [LocalVariableElement] for a local 'const' variable that has an
  * initializer.
  */
 class ConstLocalVariableElementImpl extends LocalVariableElementImpl
     with ConstVariableElement {
   /**
    * Initialize a newly created local variable element to have the given [name]
    * and [offset].
    */
   ConstLocalVariableElementImpl(String name, int offset) : super(name, offset);
@@ skipping 359 matching lines @@
    * If this element represents a constant variable, and it has an initializer,
    * a copy of the initializer for the constant.  Otherwise `null`.
    *
    * Note that in correct Dart code, all constant variables must have
    * initializers.  However, analyzer also needs to handle incorrect Dart code,
    * in which case there might be some constant variables that lack
    * initializers.
    */
   Expression _constantInitializer;
 
-  @override
-  EvaluationResultImpl evaluationResult;
+  EvaluationResultImpl _evaluationResult;
 
   Expression get constantInitializer {
     if (_constantInitializer == null && _unlinkedConst != null) {
       _constantInitializer = enclosingUnit.resynthesizerContext
           .buildExpression(this, _unlinkedConst);
     }
     return _constantInitializer;
   }
 
   void set constantInitializer(Expression constantInitializer) {
     assert(_unlinkedConst == null);
     _constantInitializer = constantInitializer;
   }
 
+  EvaluationResultImpl get evaluationResult => _evaluationResult;
+
+  void set evaluationResult(EvaluationResultImpl evaluationResult) {
+    _evaluationResult = evaluationResult;
+  }
+
   /**
    * If this element is resynthesized from the summary, return the unlinked
    * initializer, otherwise return `null`.
    */
   UnlinkedConst get _unlinkedConst;
 
   /**
    * Return a representation of the value of this variable, forcing the value
    * to be computed if it had not previously been computed, or `null` if either
    * this variable was not declared with the 'const' modifier or if the value of
@@ skipping 989 matching lines @@
       : super.forSerialized(enclosingUnit);
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
     assert(_unlinkedEnum == null);
   }
 
   @override
+  List<PropertyAccessorElement> get accessors {
+    if (_unlinkedEnum != null && _accessors == null) {
+      _resynthesizeFieldsAndPropertyAccessors();
+    }
+    return _accessors ?? const <PropertyAccessorElement>[];
+  }
+
+  @override
+  void set accessors(List<PropertyAccessorElement> accessors) {
+    assert(_unlinkedEnum == null);
+    super.accessors = accessors;
+  }
+
+  @override
   List<InterfaceType> get allSupertypes => <InterfaceType>[supertype];
 
   @override
   int get codeLength {
     if (_unlinkedEnum != null) {
       return _unlinkedEnum.codeRange?.length;
     }
     return super.codeLength;
   }
 
@@ skipping 27 matching lines @@
 
   @override
   String get documentationComment {
     if (_unlinkedEnum != null) {
       return _unlinkedEnum?.documentationComment?.text;
     }
     return super.documentationComment;
   }
 
   @override
+  List<FieldElement> get fields {
+    if (_unlinkedEnum != null && _fields == null) {
+      _resynthesizeFieldsAndPropertyAccessors();
+    }
+    return _fields ?? const <FieldElement>[];
+  }
+
+  @override
+  void set fields(List<FieldElement> fields) {
+    assert(_unlinkedEnum == null);
+    super.fields = fields;
+  }
+
+  @override
   bool get hasNonFinalField => false;
 
   @override
   bool get hasReferenceToSuper => false;
 
   @override
   bool get hasStaticMember => true;
 
   @override
   List<InterfaceType> get interfaces => const <InterfaceType>[];
@@ skipping 79 matching lines @@
   }
 
   @override
   MethodElement getMethod(String name) => null;
 
   @override
   ConstructorElement getNamedConstructor(String name) => null;
 
   @override
   bool isSuperConstructorAccessible(ConstructorElement constructor) => false;
+
+  void _resynthesizeFieldsAndPropertyAccessors() {
+    List<FieldElementImpl> fields = <FieldElementImpl>[];
+    // Build the 'index' field.
+    fields.add(new FieldElementImpl('index', -1)
+      ..enclosingElement = this
+      ..synthetic = true
+      ..final2 = true
+      ..type = context.typeProvider.intType);
+    // Build the 'values' field.
+    fields.add(new ConstFieldElementImpl_EnumValues(this));
+    // Build fields for all enum constants.
+    for (int i = 0; i < _unlinkedEnum.values.length; i++) {
+      UnlinkedEnumValue unlinkedValue = _unlinkedEnum.values[i];
+      ConstFieldElementImpl_EnumValue field =
+          new ConstFieldElementImpl_EnumValue(this, unlinkedValue, i);
+      fields.add(field);
+    }
+    // done
+    _fields = fields;
+    _accessors = fields
+        .map((FieldElementImpl field) =>
+            new PropertyAccessorElementImpl_ImplicitGetter(field)
+              ..enclosingElement = this)
+        .toList(growable: false);
+  }
 }
 
 /**
  * A base class for concrete implementations of an [ExecutableElement].
  */
 abstract class ExecutableElementImpl extends ElementImpl
     with TypeParameterizedElementMixin
     implements ExecutableElement {
   /**
    * The unlinked representation of the executable in the summary.
@@ skipping 4070 matching lines @@
  */
 class PropertyAccessorElementImpl_ImplicitGetter
     extends PropertyAccessorElementImpl {
   /**
    * Create the implicit getter and bind it to the [property].
    */
   PropertyAccessorElementImpl_ImplicitGetter(
       PropertyInducingElementImpl property)
       : super.forVariable(property) {
     property.getter = this;
+    enclosingElement = property.enclosingElement;
   }
 
   @override
   bool get hasImplicitReturnType => variable.hasImplicitType;
 
   @override
   bool get isGetter => true;
 
   @override
   DartType get returnType => variable.type;
@@ skipping 796 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }