A different approach for resynthesizing enumerations.

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 53 matching lines @@
  */
 class ClassElementImpl extends ElementImpl
     with TypeParameterizedElementMixin
     implements ClassElement {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   /**
+   * The unlinked representation of the enumeration in the summary.
+   */
+  final UnlinkedEnum _unlinkedEnum;
+
+  /**
    * A list containing all of the accessors (getters and setters) contained in
    * this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
 
   /**
    * For classes which are not mixin applications, a list containing all of the
    * constructors contained in this class, or `null` if the list of
    * constructors has not yet been built.
    *
@@ skipping 47 matching lines @@
    * this class have been inferred.
    */
   bool hasBeenInferred = false;
 
   /**
    * 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.
    */
   ClassElementImpl(String name, int offset)
       : _unlinkedClass = null,
+        _unlinkedEnum = null,
         super(name, offset);
 
   /**
    * Initialize a newly created class element to have the given [name].
    */
   ClassElementImpl.forNode(Identifier name)
       : _unlinkedClass = null,
+        _unlinkedEnum = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
-  ClassElementImpl.forSerialized(
-      this._unlinkedClass, CompilationUnitElementImpl enclosingUnit)
+  ClassElementImpl.forSerialized(this._unlinkedClass, this._unlinkedEnum,
+      CompilationUnitElementImpl enclosingUnit)
       : super.forSerialized(enclosingUnit);
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
-    assert(_unlinkedClass == null);
+    assert(_unlinkedClass == null && _unlinkedEnum == null);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
   List<PropertyAccessorElement> get accessors => _accessors;
 
   /**
    * Set the accessors contained in this class to the given [accessors].
    */
   void set accessors(List<PropertyAccessorElement> accessors) {
     for (PropertyAccessorElement accessor in accessors) {
       (accessor as PropertyAccessorElementImpl).enclosingElement = this;
     }
     this._accessors = accessors;
   }
 
   @override
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     _collectAllSupertypes(list);
     return list;
   }
 
   @override
   int get codeLength {
     if (_unlinkedClass != null) {
       return _unlinkedClass.codeRange?.length;
     }
+    if (_unlinkedEnum != null) {
+      return _unlinkedEnum.codeRange?.length;
+    }
     return super.codeLength;
   }
 
   @override
   int get codeOffset {
     if (_unlinkedClass != null) {
       return _unlinkedClass.codeRange?.offset;
     }
+    if (_unlinkedEnum != null) {
+      return _unlinkedEnum.codeRange?.offset;
+    }
     return super.codeOffset;
   }
 
   @override
   List<ConstructorElement> get constructors {
     if (!isMixinApplication) {
       assert(_constructors != null);
       return _constructors ?? ConstructorElement.EMPTY_LIST;
     }
     return _computeMixinAppConstructors();
@@ skipping 17 matching lines @@
 
   @override
   SourceRange get docRange {
     if (_unlinkedClass != null) {
       UnlinkedDocumentationComment comment =
           _unlinkedClass.documentationComment;
       return comment != null
           ? new SourceRange(comment.offset, comment.length)
           : null;
     }
+    if (_unlinkedEnum != null) {
+      UnlinkedDocumentationComment comment = _unlinkedEnum.documentationComment;
+      return comment != null
+          ? new SourceRange(comment.offset, comment.length)
+          : null;
+    }
     return super.docRange;
   }
 
   @override
   String get documentationComment {
     if (_unlinkedClass != null) {
       return _unlinkedClass?.documentationComment?.text;
     }
+    if (_unlinkedEnum != null) {
+      return _unlinkedEnum?.documentationComment?.text;
+    }
     return super.documentationComment;
   }
 
   /**
    * Return `true` if [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS] should
    * be reported for this class.
    */
   bool get doesMixinLackConstructors {
     if (!isMixinApplication && mixins.isEmpty) {
       // This class is not a mixin application and it doesn't have a "with"
@@ skipping 34 matching lines @@
     return !nearestNonMixinClass.constructors.any(isSuperConstructorAccessible);
   }
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   /**
    * Set whether this class is defined by an enum declaration.
    */
   void set enum2(bool isEnum) {
+    assert(_unlinkedClass == null && _unlinkedEnum == null);
     setModifier(Modifier.ENUM, isEnum);
   }
 
   @override
   List<FieldElement> get fields => _fields;
 
   /**
    * Set the fields contained in this class to the given [fields].
    */
   void set fields(List<FieldElement> fields) {
@@ skipping 69 matching lines @@
     if (_unlinkedClass != null && _interfaces == null) {
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _interfaces = _unlinkedClass.interfaces
           .map((EntityRef t) => context.resolveTypeRef(t, this))
           .toList(growable: false);
     }
     return _interfaces ?? const <InterfaceType>[];
   }
 
   void set interfaces(List<InterfaceType> interfaces) {
-    assert(_unlinkedClass == null);
+    assert(_unlinkedClass == null && _unlinkedEnum == null);
     _interfaces = interfaces;
   }
 
   @override
   bool get isAbstract {
     if (_unlinkedClass != null) {
       return _unlinkedClass.isAbstract;
     }
+    if (_unlinkedEnum != null) {
+      return false;
+    }
     return hasModifier(Modifier.ABSTRACT);
   }
 
   @override
-  bool get isEnum => hasModifier(Modifier.ENUM);
+  bool get isEnum {
+    if (_unlinkedClass != null) {
+      return false;
+    }
+    if (_unlinkedEnum != null) {
+      return true;
+    }
+    return hasModifier(Modifier.ENUM);
+  }
 
   @override
   bool get isMixinApplication {
     if (_unlinkedClass != null) {
       return _unlinkedClass.isMixinApplication;
     }
+    if (_unlinkedEnum != null) {
+      return false;
+    }
     return hasModifier(Modifier.MIXIN_APPLICATION);
   }
 
   @override
   bool get isOrInheritsProxy =>
       _safeIsOrInheritsProxy(this, new HashSet<ClassElement>());
 
   @override
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
@@ skipping 24 matching lines @@
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
   List<ElementAnnotation> get metadata {
     if (_unlinkedClass != null) {
       return _metadata ??=
           _buildAnnotations(enclosingUnit, _unlinkedClass.annotations);
     }
+    if (_unlinkedEnum != null) {
+      return _metadata ??=
+          _buildAnnotations(enclosingUnit, _unlinkedEnum.annotations);
+    }
     return super.metadata;
   }
 
   @override
   List<MethodElement> get methods => _methods;
 
   /**
    * Set the methods contained in this class to the given [methods].
    */
   void set methods(List<MethodElement> methods) {
+    assert(_unlinkedEnum == null);
     for (MethodElement method in methods) {
       (method as MethodElementImpl).enclosingElement = this;
     }
     this._methods = methods;
   }
 
   /**
    * Set whether this class is a mixin application.
    */
   void set mixinApplication(bool isMixinApplication) {
     assert(_unlinkedClass == null);
     setModifier(Modifier.MIXIN_APPLICATION, isMixinApplication);
   }
 
   @override
   List<InterfaceType> get mixins {
     if (_unlinkedClass != null && _mixins == null) {
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _mixins = _unlinkedClass.mixins
           .map((EntityRef t) => context.resolveTypeRef(t, this))
           .toList(growable: false);
     }
     return _mixins ?? const <InterfaceType>[];
   }
 
   void set mixins(List<InterfaceType> mixins) {
-    assert(_unlinkedClass == null);
+    assert(_unlinkedClass == null && _unlinkedEnum == null);
     _mixins = mixins;
   }
 
   @override
   String get name {
     if (_unlinkedClass != null) {
       return _unlinkedClass.name;
     }
+    if (_unlinkedEnum != null) {
+      return _unlinkedEnum.name;
+    }
     return super.name;
   }
 
   @override
   int get nameOffset {
     if (_unlinkedClass != null) {
       return _unlinkedClass.nameOffset;
     }
+    if (_unlinkedEnum != null) {
+      return _unlinkedEnum.nameOffset;
+    }
     return super.nameOffset;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedClass != null) {
       return super.typeParameters;
     }
     return _typeParameters;
   }
 
   /**
    * Set the type parameters defined for this class to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
-    assert(_unlinkedClass == null);
+    assert(_unlinkedClass == null && _unlinkedEnum == null);
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameters = typeParameters;
   }
 
   @override
-  List<UnlinkedTypeParam> get unlinkedTypeParams =>
-      _unlinkedClass.typeParameters;
+  List<UnlinkedTypeParam> get unlinkedTypeParams {
+    return _unlinkedClass?.typeParameters ?? const <UnlinkedTypeParam>[];
+  }
 
   @override
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
       String name = element.displayName;
       if (name == null || name.isEmpty) {
         return element;
       }
     }
     return null;
@@ skipping 7153 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }