Add Class.isEnum to Kernel and use it to resynthesize enums in Analyzer.

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';
@@ skipping 1616 matching lines @@
   LibraryElement get enclosingElement =>
       super.enclosingElement as LibraryElement;
 
   @override
   CompilationUnitElementImpl get enclosingUnit {
     return this;
   }
 
   @override
   List<ClassElement> get enums {
+    if (_kernelContext != null) {
+      _enums ??= _kernelContext.library.classes
+          .where((k) => k.isEnum)
+          .map((k) => new EnumElementImpl.forKernel(this, k))
+          .toList(growable: false);
+    }
     if (_unlinkedUnit != null) {
       _enums ??= _unlinkedUnit.enums
           .map((e) => new EnumElementImpl.forSerialized(e, this))
           .toList(growable: false);
     }
     return _enums ?? const <ClassElement>[];
   }
 
   /**
    * Set the enums contained in this compilation unit to the given [enums].
@@ skipping 139 matching lines @@
     this._typeAliases = typeAliases;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => null;
 
   @override
   List<ClassElement> get types {
     if (_kernelContext != null) {
       _types ??= _kernelContext.library.classes
-          .where((k) => !k.isSyntheticMixinImplementation)
+          .where((k) => !k.isEnum && !k.isSyntheticMixinImplementation)
           .map((k) => new ClassElementImpl.forKernel(this, k))
           .toList(growable: false);
     }
     if (_unlinkedUnit != null) {
       _types ??= _unlinkedUnit.classes
           .map((c) => new ClassElementImpl.forSerialized(c, this))
           .toList(growable: false);
     }
     return _types ?? const <ClassElement>[];
   }
@@ skipping 187 matching lines @@
   ConstFieldElementImpl.forSerialized(
       UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
       : super.forSerialized(unlinkedVariable, enclosingElement);
 }
 
 /**
  * A field element representing an enum constant.
  */
 class ConstFieldElementImpl_EnumValue extends ConstFieldElementImpl_ofEnum {
   final UnlinkedEnumValue _unlinkedEnumValue;
+  final kernel.Field _kernelEnumValue;
   final int _index;
 
-  ConstFieldElementImpl_EnumValue(
-      EnumElementImpl enumElement, this._unlinkedEnumValue, this._index)
+  ConstFieldElementImpl_EnumValue(EnumElementImpl enumElement,
+      this._unlinkedEnumValue, this._kernelEnumValue, this._index)
       : super(enumElement);
 
   @override
   String get documentationComment {
+    if (_kernelEnumValue != null) {
+      return _kernelEnumValue.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 (_kernelEnumValue != null) {
+      return _kernelEnumValue.name.name;
+    }
     if (_unlinkedEnumValue != null) {
       return _unlinkedEnumValue.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == -1 && _unlinkedEnumValue != null) {
@@ skipping 1576 matching lines @@
 /**
  * An [AbstractClassElementImpl] which is an enum.
  */
 class EnumElementImpl extends AbstractClassElementImpl {
   /**
    * The unlinked representation of the enum in the summary.
    */
   final UnlinkedEnum _unlinkedEnum;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.Class _kernel;
+
+  /**
    * The type defined by the enum.
    */
   InterfaceType _type;
 
   /**
    * Initialize a newly created class element to have the given [name] at the
    * given [offset] in the file that contains the declaration of this element.
    */
   EnumElementImpl(String name, int offset)
       : _unlinkedEnum = null,
+        _kernel = null,
         super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  EnumElementImpl.forKernel(
+      CompilationUnitElementImpl enclosingUnit, this._kernel)
+      : _unlinkedEnum = null,
+        super.forSerialized(enclosingUnit);
+
+  /**
    * Initialize a newly created class element to have the given [name].
    */
   EnumElementImpl.forNode(Identifier name)
       : _unlinkedEnum = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   EnumElementImpl.forSerialized(
       this._unlinkedEnum, CompilationUnitElementImpl enclosingUnit)
-      : super.forSerialized(enclosingUnit);
+      : _kernel = null,
+        super.forSerialized(enclosingUnit);
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
     _assertNotResynthesized(_unlinkedEnum);
   }
 
   @override
   List<PropertyAccessorElement> get accessors {
-    if (_unlinkedEnum != null && _accessors == null) {
-      _resynthesizeFieldsAndPropertyAccessors();
+    if (_accessors == null) {
+      if (_kernel != null || _unlinkedEnum != null) {
+        _resynthesizeFieldsAndPropertyAccessors();
+      }
     }
     return _accessors ?? const <PropertyAccessorElement>[];
   }
 
   @override
   void set accessors(List<PropertyAccessorElement> accessors) {
     _assertNotResynthesized(_unlinkedEnum);
     super.accessors = accessors;
   }
 
@@ skipping 20 matching lines @@
   List<ConstructorElement> get constructors {
     // 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.
     return const <ConstructorElement>[];
   }
 
   @override
   String get documentationComment {
+    if (_kernel != null) {
+      return _kernel.documentationComment;
+    }
     if (_unlinkedEnum != null) {
       return _unlinkedEnum?.documentationComment?.text;
     }
     return super.documentationComment;
   }
 
   @override
   List<FieldElement> get fields {
-    if (_unlinkedEnum != null && _fields == null) {
-      _resynthesizeFieldsAndPropertyAccessors();
+    if (_fields == null) {
+      if (_kernel != null || _unlinkedEnum != null) {
+        _resynthesizeFieldsAndPropertyAccessors();
+      }
     }
     return _fields ?? const <FieldElement>[];
   }
 
   @override
   void set fields(List<FieldElement> fields) {
     _assertNotResynthesized(_unlinkedEnum);
     super.fields = fields;
   }
 
@@ skipping 37 matching lines @@
   }
 
   @override
   List<MethodElement> get methods => const <MethodElement>[];
 
   @override
   List<InterfaceType> get mixins => const <InterfaceType>[];
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name;
+    }
     if (_unlinkedEnum != null) {
       return _unlinkedEnum.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedEnum != null && _unlinkedEnum.nameOffset != 0) {
@@ skipping 46 matching lines @@
     List<FieldElementImpl> fields = <FieldElementImpl>[];
     // Build the 'index' field.
     fields.add(new FieldElementImpl('index', -1)
       ..enclosingElement = this
       ..isSynthetic = true
       ..isFinal = 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);
+    if (_kernel != null) {
+      for (int i = 0; i < _kernel.fields.length; i++) {
+        kernel.Field kernelField = _kernel.fields[i];
+        if (kernelField.name.name == 'index' ||
+            kernelField.name.name == 'values') {
+          continue;
+        }
+        ConstFieldElementImpl_EnumValue field =
+            new ConstFieldElementImpl_EnumValue(this, null, kernelField, i);
+        fields.add(field);
+      }
+    }
+    if (_unlinkedEnum != null) {
+      for (int i = 0; i < _unlinkedEnum.values.length; i++) {
+        UnlinkedEnumValue unlinkedValue = _unlinkedEnum.values[i];
+        ConstFieldElementImpl_EnumValue field =
+            new ConstFieldElementImpl_EnumValue(this, unlinkedValue, null, i);
+        fields.add(field);
+      }
     }
     // done
     _fields = fields;
     _accessors = fields
         .map((FieldElementImpl field) =>
             new PropertyAccessorElementImpl_ImplicitGetter(field)
               ..enclosingElement = this)
         .toList(growable: false);
   }
 }
@@ skipping 2812 matching lines @@
     }
     for (ExportElement exportElement in exports) {
       ExportElementImpl exportElementImpl = exportElement;
       if (exportElementImpl.identifier == identifier) {
         return exportElementImpl;
       }
     }
     return null;
   }
 
+  ClassElement getEnum(String name) {
+    ClassElement element = _definingCompilationUnit.getEnum(name);
+    if (element != null) {
+      return element;
+    }
+    for (CompilationUnitElement part in _parts) {
+      element = part.getEnum(name);
+      if (element != null) {
+        return element;
+      }
+    }
+    return null;
+  }
+
   @override
   List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) {
     var imports = this.imports;
     int count = imports.length;
     List<ImportElement> importList = new List<ImportElement>();
     for (int i = 0; i < count; i++) {
       if (identical(imports[i].prefix, prefixElement)) {
         importList.add(imports[i]);
       }
     }
@@ skipping 3020 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }