Implement 'node' for ClassElement and FieldElement for enums.

pkg/analyzer/lib/src/generated/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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 199 matching lines @@
    *
    * <b>Note:</b> Because the element model represents the state of the code, it
    * is possible for it to be semantically invalid. In particular, it is not
    * safe to assume that the inheritance structure of a class does not contain a
    * cycle. Clients that traverse the inheritance structure must explicitly
    * guard against infinite loops.
    */
   List<InterfaceType> get mixins;
 
   /**
-   * Return the resolved [ClassDeclaration] node that declares this
-   * [ClassElement].
+   * Return the resolved [ClassDeclaration] or [EnumDeclaration] node that
+   * declares this [ClassElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
-  ClassDeclaration get node;
+  AstNode get node;
 
   /**
    * Return the superclass of this class, or `null` if the class represents the
    * class 'Object'. All other classes will have a non-`null` superclass. If the
    * superclass was not explicitly declared then the implicit superclass
    * 'Object' will be returned.
    *
    * <b>Note:</b> Because the element model represents the state of the code, it
    * is possible for it to be semantically invalid. In particular, it is not
    * safe to assume that the inheritance structure of a class does not contain a
@@ skipping 450 matching lines @@
 
   /**
    * Set whether an error has reported explaining why this class is an
    * invalid mixin application.
    */
   void set mixinErrorsReported(bool value) {
     setModifier(Modifier.MIXIN_ERRORS_REPORTED, value);
   }
 
   @override
-  ClassDeclaration get node =>
-      getNodeMatching((node) => node is ClassDeclaration);
+  AstNode get node {
+    if (isEnum) {
+      return getNodeMatching((node) => node is EnumDeclaration);
+    } else {
+      return getNodeMatching((node) => node is ClassDeclaration);
+    }
+  }
 
   /**
    * Set whether this class is defined by a typedef construct.
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
 
   @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
@@ skipping 2966 matching lines @@
 
 /**
  * A field defined within a type.
  */
 abstract class FieldElement
     implements ClassMemberElement, PropertyInducingElement {
   /**
    * Return {@code true} if this element is an enum constant.
    */
   bool get isEnumConstant;
+
+  /**
+   * Return the resolved [VariableDeclaration] or [EnumConstantDeclaration]
+   * node that declares this [FieldElement].
+   *
+   * This method is expensive, because resolved AST might be evicted from cache,
+   * so parsing and resolving will be performed.
+   */
+  @override
+  AstNode get node;
 }
 
 /**
  * A concrete implementation of a [FieldElement].
  */
 class FieldElementImpl extends PropertyInducingElementImpl
     implements FieldElement {
   /**
    * An empty list of field elements.
    */
@@ skipping 16 matching lines @@
   @override
   bool get isEnumConstant =>
       enclosingElement != null ? enclosingElement.isEnum : false;
 
   @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   @override
   ElementKind get kind => ElementKind.FIELD;
 
+  @override
+  AstNode get node {
+    if (isEnumConstant) {
+      return getNodeMatching((node) => node is EnumConstantDeclaration);
+    } else {
+      return getNodeMatching((node) => node is VariableDeclaration);
+    }
+  }
+
   /**
    * Set whether this field is static.
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 }
@@ skipping 1849 matching lines @@
    * The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named
    *   <i>m</i> that is accessible to <i>L</i>, then that getter (respectively
    *   setter) is the result of the lookup. Otherwise, if <i>C</i> has a
    *   superclass <i>S</i>, then the result of the lookup is the result of
    *   looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect
    *   to <i>L</i>. Otherwise, we say that the lookup has failed.
    * </blockquote>
    */
-  PropertyAccessorElement lookUpGetter(
-      String name, LibraryElement library);
+  PropertyAccessorElement lookUpGetter(String name, LibraryElement library);
 
   /**
    * Return the element representing the getter that results from looking up the
    * getter with the given [name] in the superclass of this class with respect
    * to the given [library], or `null` if the look up fails. The behavior of
    * this method is defined by the Dart Language Specification in section
    * 12.15.1:
    * <blockquote>
    * The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
@@ skipping 34 matching lines @@
    * <blockquote>
    * The result of looking up method <i>m</i> in class <i>C</i> with respect to
    * library <i>L</i> is:
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible
    *   to <i>L</i>, then that method is the result of the lookup. Otherwise, if
    * <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the
    * result of looking up method <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    */
-  MethodElement lookUpMethodInSuperclass(
-      String name, LibraryElement library);
+  MethodElement lookUpMethodInSuperclass(String name, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the
    * setter with the given [name] in this class with respect to the given
    * [library], or `null` if the look up fails. The behavior of this method is
    * defined by the Dart Language Specification in section 12.16:
    * <blockquote>
    * The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named
    *   <i>m</i> that is accessible to <i>L</i>, then that getter (respectively
    *   setter) is the result of the lookup. Otherwise, if <i>C</i> has a
    *   superclass <i>S</i>, then the result of the lookup is the result of
    *   looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect
    *   to <i>L</i>. Otherwise, we say that the lookup has failed.
    * </blockquote>
    */
-  PropertyAccessorElement lookUpSetter(
-      String name, LibraryElement library);
+  PropertyAccessorElement lookUpSetter(String name, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the
    * setter with the given [name] in the superclass of this class with respect
    * to the given [library], or `null` if the look up fails. The behavior of
    * this method is defined by the Dart Language Specification in section 12.16:
    * <blockquote>
    * The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named
@@ skipping 813 matching lines @@
    * given [type] to Object, where the given [depth] is the length of the
    * longest path from the subtype to this type. The set of [visitedTypes] is
    * used to prevent infinite recursion in the case of a cyclic type structure.
    *
    * See [computeLongestInheritancePathToObject], and [getLeastUpperBound].
    */
   static int _computeLongestInheritancePathToObject(
       InterfaceType type, int depth, HashSet<ClassElement> visitedTypes) {
     ClassElement classElement = type.element;
     // Object case
-    if (classElement.supertype == null ||
-        visitedTypes.contains(classElement)) {
+    if (classElement.supertype == null || visitedTypes.contains(classElement)) {
       return depth;
     }
     int longestPath = 1;
     try {
       visitedTypes.add(classElement);
       List<InterfaceType> superinterfaces = classElement.interfaces;
       int pathLength;
       if (superinterfaces.length > 0) {
         // loop through each of the superinterfaces recursively calling this
         // method and keeping track of the longest path to return
@@ skipping 739 matching lines @@
   /**
    * The length of the visible range for this element, or `-1` if this element
    * does not have a visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
    * Initialize a newly created method element to have the given [name] and
    * [offset].
    */
-  LocalVariableElementImpl(String name, int offset)
-      : super(name, offset);
+  LocalVariableElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created local variable element to have the given [name].
    */
   LocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
   String get identifier {
     int enclosingOffset =
         enclosingElement != null ? enclosingElement.nameOffset : 0;
@@ skipping 374 matching lines @@
     return buffer.toString();
   }
 
   /**
    * If the given [method]'s type is different when any type parameters from the
    * defining type's declaration are replaced with the actual type arguments
    * from the [definingType], create a method member representing the given
    * method. Return the member that was created, or the base method if no member
    * was created.
    */
-  static MethodElement from(
-      MethodElement method, InterfaceType definingType) {
+  static MethodElement from(MethodElement method, InterfaceType definingType) {
     if (method == null || definingType.typeArguments.length == 0) {
       return method;
     }
     FunctionType baseType = method.type;
     List<DartType> argumentTypes = definingType.typeArguments;
     List<DartType> parameterTypes = definingType.element.type.typeArguments;
     FunctionType substitutedType =
         baseType.substitute2(argumentTypes, parameterTypes);
     if (baseType == substitutedType) {
       return method;
@@ skipping 1262 matching lines @@
   /**
    * The propagated type of this variable, or `null` if type propagation has not
    * been performed.
    */
   DartType propagatedType;
 
   /**
    * Initialize a newly created synthetic element to have the given [name] and
    * [offset].
    */
-  PropertyInducingElementImpl(String name, int offset)
-      : super(name, offset);
+  PropertyInducingElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created element to have the given [name].
    */
   PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
 }
 
 /**
  * A visitor that will recursively visit all of the element in an element model.
  * For example, using an instance of this class to visit a
@@ skipping 286 matching lines @@
   /**
    * An empty list of top-level variable elements.
    */
   static const List<TopLevelVariableElement> EMPTY_ARRAY =
       const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the
    * given [name] and [offset].
    */
-  TopLevelVariableElementImpl(String name, int offset)
-      : super(name, offset);
+  TopLevelVariableElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
   TopLevelVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
   bool get isStatic => true;
 
@@ skipping 343 matching lines @@
   /**
    * The type representing the bound associated with this parameter, or `null`
    * if this parameter does not have an explicit bound.
    */
   DartType bound;
 
   /**
    * Initialize a newly created method element to have the given [name] and
    * [offset].
    */
-  TypeParameterElementImpl(String name, int offset)
-      : super(name, offset);
+  TypeParameterElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created type parameter element to have the given [name].
    */
   TypeParameterElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
@@ skipping 757 matching lines @@
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }