Rename Element.node

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 214 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] 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
-  NamedCompilationUnitMember 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
    * cycle. Clients that traverse the inheritance structure must explicitly
    * guard against infinite loops.
@@ skipping 14 matching lines @@
   /**
    * Return the unnamed constructor declared in this class, or `null` if this
    * class does not declare an unnamed constructor but does declare named
    * constructors. The returned constructor will be synthetic if this class does
    * not declare any constructors, in which case it will represent the default
    * constructor for the class.
    */
   ConstructorElement get unnamedConstructor;
 
   /**
+   * 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
+  NamedCompilationUnitMember computeNode();
+
+  /**
    * Return the field (synthetic or explicit) defined in this class that has the
    * given [name], or `null` if this class does not define a field with the
    * given name.
    */
   FieldElement getField(String name);
 
   /**
    * Return the element representing the getter with the given [name] that is
    * declared in this class, or `null` if this class does not declare a getter
    * with the given name.
@@ skipping 427 matching lines @@
   bool get mixinErrorsReported => hasModifier(Modifier.MIXIN_ERRORS_REPORTED);
 
   /**
    * 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
-  NamedCompilationUnitMember get node {
-    if (isEnum) {
-      return getNodeMatching((node) => node is EnumDeclaration);
-    } else {
-      return getNodeMatching(
-          (node) => node is ClassDeclaration || node is ClassTypeAlias);
-    }
-  }
-
   /**
    * 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 44 matching lines @@
         if (i > 0) {
           buffer.write(", ");
         }
         (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
       }
       buffer.write(">");
     }
   }
 
   @override
+  NamedCompilationUnitMember computeNode() {
+    if (isEnum) {
+      return getNodeMatching((node) => node is EnumDeclaration);
+    } else {
+      return getNodeMatching(
+          (node) => node is ClassDeclaration || node is ClassTypeAlias);
+    }
+  }
+
+  @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have
     // thrown a CCE if any of the elements in the arrays were not of the
     // expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
@@ skipping 403 matching lines @@
    */
   List<FunctionTypeAliasElement> get functionTypeAliases;
 
   /**
    * Return `true` if this compilation unit defines a top-level function named
    * `loadLibrary`.
    */
   bool get hasLoadLibraryFunction;
 
   /**
-   * Return the resolved [CompilationUnit] node that declares this element.
-   *
-   * This method is expensive, because resolved AST might be evicted from cache,
-   * so parsing and resolving will be performed.
-   */
-  @override
-  CompilationUnit get node;
-
-  /**
    * Return a list containing all of the top-level variables contained in this
    * compilation unit.
    */
   List<TopLevelVariableElement> get topLevelVariables;
 
   /**
    * Return a list containing all of the classes contained in this compilation
    * unit.
    */
   List<ClassElement> get types;
 
   /**
+   * Return the resolved [CompilationUnit] node that declares this element.
+   *
+   * This method is expensive, because resolved AST might be evicted from cache,
+   * so parsing and resolving will be performed.
+   */
+  @override
+  CompilationUnit computeNode();
+
+  /**
    * Return the element at the given [offset], maybe `null` if no such element.
    */
   Element getElementAt(int offset);
 
   /**
    * Return the enum defined in this compilation unit that has the given [name],
    * or `null` if this compilation unit does not define an enum with the given
    * name.
    */
   ClassElement getEnum(String name);
@@ skipping 138 matching lines @@
     return false;
   }
 
   @override
   String get identifier => source.encoding;
 
   @override
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
 
   @override
-  CompilationUnit get node => unit;
-
-  @override
   List<TopLevelVariableElement> get topLevelVariables => _variables;
 
   /**
    * Set the top-level variables contained in this compilation unit to the given
    * [variables].
    */
   void set topLevelVariables(List<TopLevelVariableElement> variables) {
     for (TopLevelVariableElement field in variables) {
       (field as TopLevelVariableElementImpl).enclosingElement = this;
     }
@@ skipping 41 matching lines @@
   @override
   void appendTo(StringBuffer buffer) {
     if (source == null) {
       buffer.write("{compilation unit}");
     } else {
       buffer.write(source.fullName);
     }
   }
 
   @override
+  CompilationUnit computeNode() => unit;
+
+  @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have
     // thrown a CCE if any of the elements in the arrays were not of the
     // expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
@@ skipping 184 matching lines @@
    */
   bool get isFactory;
 
   /**
    * Return the offset of the character immediately following the last character
    * of this constructor's name, or `null` if not named.
    */
   int get nameEnd;
 
   /**
-   * Return the resolved [ConstructorDeclaration] node that declares this
-   * [ConstructorElement] .
-   *
-   * This method is expensive, because resolved AST might be evicted from cache,
-   * so parsing and resolving will be performed.
-   */
-  @override
-  ConstructorDeclaration get node;
-
-  /**
    * Return the offset of the `.` before this constructor name, or `null` if
    * not named.
    */
   int get periodOffset;
 
   /**
    * Return the constructor to which this constructor is redirecting, or `null`
    * if this constructor does not redirect to another constructor or if the
    * library containing this constructor has not yet been resolved.
    */
   ConstructorElement get redirectedConstructor;
+
+  /**
+   * Return the resolved [ConstructorDeclaration] node that declares this
+   * [ConstructorElement] .
+   *
+   * This method is expensive, because resolved AST might be evicted from cache,
+   * so parsing and resolving will be performed.
+   */
+  @override
+  ConstructorDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [ConstructorElement].
  */
 class ConstructorElementImpl extends ExecutableElementImpl
     implements ConstructorElement {
   /**
    * An empty list of constructor elements.
    */
@@ skipping 80 matching lines @@
   @override
   bool get isFactory => hasModifier(Modifier.FACTORY);
 
   @override
   bool get isStatic => false;
 
   @override
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
   @override
-  ConstructorDeclaration get node =>
-      getNodeMatching((node) => node is ConstructorDeclaration);
-
-  @override
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     if (enclosingElement == null) {
       String message;
       String name = displayName;
       if (name != null && !name.isEmpty) {
         message =
             'Found constructor element named $name with no enclosing element';
       } else {
         message = 'Found unnamed constructor element with no enclosing element';
       }
       AnalysisEngine.instance.logger.logError(message);
       buffer.write('<unknown class>');
     } else {
       buffer.write(enclosingElement.displayName);
     }
     String name = displayName;
     if (name != null && !name.isEmpty) {
       buffer.write(".");
       buffer.write(name);
     }
     super.appendTo(buffer);
   }
+
+  @override
+  ConstructorDeclaration computeNode() =>
+      getNodeMatching((node) => node is ConstructorDeclaration);
 }
 
 /**
  * A constructor element defined in a parameterized type where the values of the
  * type parameters are known.
  */
 class ConstructorMember extends ExecutableMember implements ConstructorElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
@@ skipping 16 matching lines @@
   @override
   bool get isDefaultConstructor => baseElement.isDefaultConstructor;
 
   @override
   bool get isFactory => baseElement.isFactory;
 
   @override
   int get nameEnd => baseElement.nameEnd;
 
   @override
-  ConstructorDeclaration get node => baseElement.node;
-
-  @override
   int get periodOffset => baseElement.periodOffset;
 
   @override
   ConstructorElement get redirectedConstructor =>
       from(baseElement.redirectedConstructor, definingType);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   @override
+  ConstructorDeclaration computeNode() => baseElement.computeNode();
+
+  @override
   String toString() {
     ConstructorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     StringBuffer buffer = new StringBuffer();
     buffer.write(baseElement.enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
       buffer.write(".");
       buffer.write(name);
@@ skipping 247 matching lines @@
 
   @override
   EvaluationResultImpl get evaluationResult => _result;
 
   @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 
   @override
-  DefaultFormalParameter get node =>
+  DefaultFormalParameter computeNode() =>
       getNodeMatching((node) => node is DefaultFormalParameter);
 }
 
 /**
  * The synthetic element representing the declaration of the type `dynamic`.
  */
 class DynamicElementImpl extends ElementImpl {
   /**
    * Return the unique instance of this class.
    */
@@ skipping 228 matching lines @@
   /**
    * Return the resolved [AstNode] node that declares this element, or `null` if
    * this element is synthetic or isn't contained in a compilation unit, such as
    * a [LibraryElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    */
+  @deprecated
   AstNode get node;
 
   /**
    * Return the source that contains this element, or `null` if this element is
    * not contained in a source.
    */
   Source get source;
 
   /**
    * Return the resolved [CompilationUnit] that declares this element, or `null`
@@ skipping 16 matching lines @@
    * `null` if this element does not have a documentation comment associated
    * with it. This can be a long-running operation if the information needed to
    * access the comment is not cached.
    *
    * Throws [AnalysisException] if the documentation comment could not be
    * determined because the analysis could not be performed
    */
   String computeDocumentationComment();
 
   /**
+   * Return the resolved [AstNode] node that declares this element, or `null` if
+   * this element is synthetic or isn't contained in a compilation unit, such as
+   * a [LibraryElement].
+   *
+   * This method is expensive, because resolved AST might be evicted from cache,
+   * so parsing and resolving will be performed.
+   *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   */
+  AstNode computeNode();
+
+  /**
    * Return the most immediate ancestor of this element for which the
    * [predicate] returns `true`, or `null` if there is no such ancestor. Note
    * that this element will never be returned.
    */
   Element getAncestor(Predicate<Element> predicate);
 
   /**
    * Return a display name for the given element that includes the path to the
    * compilation unit in which the type is defined. If [shortName] is `null`
    * then [getDisplayName] will be used as the name of this element. Otherwise
@@ skipping 329 matching lines @@
   /**
    * Sets the offset of the name of this element in the file that contains the
    * declaration of this element.
    */
   void set nameOffset(int offset) {
     _nameOffset = offset;
     _cachedHashCode = null;
     _cachedLocation = null;
   }
 
+  @deprecated
   @override
-  AstNode get node => getNodeMatching((node) => node is AstNode);
+  AstNode get node => computeNode();
 
   @override
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
 
   /**
@@ skipping 33 matching lines @@
 
   @override
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
 
+  @override
+  AstNode computeNode() => getNodeMatching((node) => node is AstNode);
+
   /**
    * Set this element as the enclosing element for given [element].
    */
   void encloseElement(ElementImpl element) {
     element.enclosingElement = this;
   }
 
   @override
   Element getAncestor(Predicate<Element> predicate) {
     Element ancestor = _enclosingElement;
@@ skipping 1043 matching lines @@
   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;
+  AstNode computeNode();
 }
 
 /**
  * A concrete implementation of a [FieldElement].
  */
 class FieldElementImpl extends PropertyInducingElementImpl
     with PotentiallyConstVariableElement implements FieldElement {
   /**
    * An empty list of field elements.
    */
@@ skipping 17 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);
+
+  @override
+  AstNode computeNode() {
+    if (isEnumConstant) {
+      return getNodeMatching((node) => node is EnumConstantDeclaration);
+    } else {
+      return getNodeMatching((node) => node is VariableDeclaration);
+    }
+  }
 }
 
 /**
  * A field formal parameter defined within a constructor element.
  */
 abstract class FieldFormalParameterElement implements ParameterElement {
   /**
    * Return the field element associated with this field formal parameter, or
    * `null` if the parameter references a field that doesn't exist.
    */
@@ skipping 77 matching lines @@
   PropertyAccessorElement get getter =>
       PropertyAccessorMember.from(baseElement.getter, definingType);
 
   @override
   bool get isEnumConstant => baseElement.isEnumConstant;
 
   @override
   bool get isStatic => baseElement.isStatic;
 
   @override
-  VariableDeclaration get node => baseElement.node;
-
-  @override
   DartType get propagatedType => substituteFor(baseElement.propagatedType);
 
   @override
   PropertyAccessorElement get setter =>
       PropertyAccessorMember.from(baseElement.setter, definingType);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 
   @override
+  VariableDeclaration computeNode() => baseElement.computeNode();
+
+  @override
   String toString() => '$type $displayName';
 
   /**
    * If the given [field]'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 field member representing the given
    * field. Return the member that was created, or the base field if no member
    * was created.
    */
   static FieldElement from(FieldElement field, InterfaceType definingType) {
@@ skipping 78 matching lines @@
    */
   bool get isEntryPoint;
 
   /**
    * Return the resolved function declaration node that declares this element.
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
-  FunctionDeclaration get node;
+  FunctionDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [FunctionElement].
  */
 class FunctionElementImpl extends ExecutableElementImpl
     implements FunctionElement {
   /**
    * An empty list of function elements.
    */
@@ skipping 42 matching lines @@
     return isStatic && displayName == FunctionElement.MAIN_FUNCTION_NAME;
   }
 
   @override
   bool get isStatic => enclosingElement is CompilationUnitElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
-  FunctionDeclaration get node =>
-      getNodeMatching((node) => node is FunctionDeclaration);
-
-  @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     String name = displayName;
     if (name != null) {
       buffer.write(name);
     }
     super.appendTo(buffer);
   }
 
+  @override
+  FunctionDeclaration computeNode() =>
+      getNodeMatching((node) => node is FunctionDeclaration);
+
   /**
    * Set the visible range for this element to the range starting at the given
    * [offset] with the given [length].
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 }
 
@@ skipping 132 matching lines @@
   static List<FunctionTypeAliasElement> EMPTY_LIST =
       new List<FunctionTypeAliasElement>(0);
 
   /**
    * Return the compilation unit in which this type alias is defined.
    */
   @override
   CompilationUnitElement get enclosingElement;
 
   /**
-   * Return the resolved function type alias node that declares this element.
-   *
-   * This method is expensive, because resolved AST might be evicted from cache,
-   * so parsing and resolving will be performed.
-   */
-  @override
-  FunctionTypeAlias get node;
-
-  /**
    * Return a list containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> get parameters;
 
   /**
    * Return the return type defined by this type alias.
    */
   DartType get returnType;
 
   /**
    * Return the type of function defined by this type alias.
    */
   FunctionType get type;
 
   /**
    * Return a list containing all of the type parameters defined for this type.
    */
   List<TypeParameterElement> get typeParameters;
+
+  /**
+   * Return the resolved function type alias node that declares this element.
+   *
+   * This method is expensive, because resolved AST might be evicted from cache,
+   * so parsing and resolving will be performed.
+   */
+  @override
+  FunctionTypeAlias computeNode();
 }
 
 /**
  * A concrete implementation of a [FunctionTypeAliasElement].
  */
 class FunctionTypeAliasElementImpl extends ElementImpl
     implements FunctionTypeAliasElement {
   /**
    * An empty array of type alias elements.
    */
@@ skipping 37 matching lines @@
   FunctionTypeAliasElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
   CompilationUnitElement get enclosingElement =>
       super.enclosingElement as CompilationUnitElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
-  FunctionTypeAlias get node =>
-      getNodeMatching((node) => node is FunctionTypeAlias);
-
-  @override
   List<ParameterElement> get parameters => _parameters;
 
   /**
    * Set the parameters defined by this type alias to the given [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     if (parameters != null) {
       for (ParameterElement parameter in parameters) {
         (parameter as ParameterElementImpl).enclosingElement = this;
       }
@@ skipping 45 matching lines @@
     if (type != null) {
       buffer.write(Element.RIGHT_ARROW);
       buffer.write(type.returnType);
     } else if (returnType != null) {
       buffer.write(Element.RIGHT_ARROW);
       buffer.write(returnType);
     }
   }
 
   @override
+  FunctionTypeAlias computeNode() =>
+      getNodeMatching((node) => node is FunctionTypeAlias);
+
+  @override
   ElementImpl getChild(String identifier) {
     for (VariableElement parameter in _parameters) {
       if ((parameter as VariableElementImpl).identifier == identifier) {
         return parameter as VariableElementImpl;
       }
     }
     for (TypeParameterElement typeParameter in _typeParameters) {
       if ((typeParameter as TypeParameterElementImpl).identifier ==
           identifier) {
         return typeParameter as TypeParameterElementImpl;
@@ skipping 2945 matching lines @@
       const <LocalVariableElement>[];
 
   /**
    * Return the resolved [VariableDeclaration] node that declares this
    * [LocalVariableElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
-  VariableDeclaration get node;
+  VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [LocalVariableElement].
  */
 class LocalVariableElementImpl extends VariableElementImpl
     with PotentiallyConstVariableElement implements LocalVariableElement {
   /**
    * An empty list of field elements.
    */
@@ skipping 36 matching lines @@
       hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
 
   @override
   bool get isPotentiallyMutatedInScope =>
       hasModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE);
 
   @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
-  VariableDeclaration get node =>
-      getNodeMatching((node) => node is VariableDeclaration);
-
-  @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
   }
 
+  @override
+  VariableDeclaration computeNode() =>
+      getNodeMatching((node) => node is VariableDeclaration);
+
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
     setModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT, true);
   }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
@@ skipping 76 matching lines @@
 
   @override
   List<ElementAnnotation> get metadata => _baseElement.metadata;
 
   @override
   String get name => _baseElement.name;
 
   @override
   int get nameOffset => _baseElement.nameOffset;
 
+  @deprecated
   @override
-  AstNode get node => _baseElement.node;
+  AstNode get node => computeNode();
 
   @override
   Source get source => _baseElement.source;
 
   @override
   CompilationUnit get unit => _baseElement.unit;
 
   @override
   String computeDocumentationComment() =>
       _baseElement.computeDocumentationComment();
 
   @override
+  AstNode computeNode() => _baseElement.computeNode();
+
+  @override
   Element getAncestor(Predicate<Element> predicate) =>
       baseElement.getAncestor(predicate);
 
   @override
   String getExtendedDisplayName(String shortName) =>
       _baseElement.getExtendedDisplayName(shortName);
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       _baseElement.isAccessibleIn(library);
@@ skipping 63 matching lines @@
   static const List<MethodElement> EMPTY_LIST = const <MethodElement>[];
 
   /**
    * Return the resolved [MethodDeclaration] node that declares this
    * [MethodElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
-  MethodDeclaration get node;
+  MethodDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [MethodElement].
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty list of method elements.
    */
   @deprecated // Use MethodElement.EMPTY_LIST
@@ skipping 52 matching lines @@
   String get name {
     String name = super.name;
     if (isOperator && name == "-") {
       if (parameters.length == 0) {
         return "unary-";
       }
     }
     return super.name;
   }
 
-  @override
-  MethodDeclaration get node =>
-      getNodeMatching((node) => node is MethodDeclaration);
-
   /**
    * Set whether this method is static.
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(displayName);
     super.appendTo(buffer);
   }
+
+  @override
+  MethodDeclaration computeNode() =>
+      getNodeMatching((node) => node is MethodDeclaration);
 }
 
 /**
  * A method element defined in a parameterized type where the values of the type
  * parameters are known.
  */
 class MethodMember extends ExecutableMember implements MethodElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
    */
   MethodMember(MethodElement baseElement, InterfaceType definingType)
       : super(baseElement, definingType);
 
   @override
   MethodElement get baseElement => super.baseElement as MethodElement;
 
   @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
   @override
-  MethodDeclaration get node => baseElement.node;
-
-  @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
   @override
+  MethodDeclaration computeNode() => baseElement.computeNode();
+
+  @override
   String toString() {
     MethodElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     StringBuffer buffer = new StringBuffer();
     buffer.write(baseElement.enclosingElement.displayName);
     buffer.write(".");
     buffer.write(baseElement.displayName);
     buffer.write("(");
     int parameterCount = parameters.length;
@@ skipping 274 matching lines @@
 
   @override
   List<ElementAnnotation> get metadata => ElementAnnotation.EMPTY_LIST;
 
   @override
   String get name => _name;
 
   @override
   int get nameOffset => -1;
 
+  @deprecated
   @override
   AstNode get node => null;
 
   @override
   Source get source => null;
 
   @override
   DartType get type => DynamicTypeImpl.instance;
 
   @override
   CompilationUnit get unit => null;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
 
   @override
   String computeDocumentationComment() => null;
 
   @override
+  AstNode computeNode() => null;
+
+  @override
   Element getAncestor(Predicate<Element> predicate) => null;
 
   @override
   String getExtendedDisplayName(String shortName) {
     if (shortName != null) {
       return shortName;
     }
     return displayName;
   }
 
@@ skipping 168 matching lines @@
   /**
    * Return the Dart code of the default value, or `null` if no default value.
    */
   String get defaultValueCode;
 
   /**
    * Return `true` if this parameter is an initializing formal parameter.
    */
   bool get isInitializingFormal;
 
-  @override
-  FormalParameter get node;
-
   /**
    * Return the kind of this parameter.
    */
   ParameterKind get parameterKind;
 
   /**
    * Return a list containing all of the parameters defined by this parameter.
    * A parameter will only define other parameters if it is a function typed
    * parameter.
    */
   List<ParameterElement> get parameters;
+
+  @override
+  FormalParameter computeNode();
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
     with PotentiallyConstVariableElement implements ParameterElement {
   /**
    * An empty list of parameter elements.
    */
@@ skipping 57 matching lines @@
       hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
 
   @override
   bool get isPotentiallyMutatedInScope =>
       hasModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE);
 
   @override
   ElementKind get kind => ElementKind.PARAMETER;
 
   @override
-  FormalParameter get node =>
-      getNodeMatching((node) => node is FormalParameter);
-
-  @override
   List<ParameterElement> get parameters => _parameters;
 
   /**
    * Set the parameters defined by this executable element to the given
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
@@ skipping 42 matching lines @@
         buffer.write(": ");
       }
       if (parameterKind == ParameterKind.POSITIONAL) {
         buffer.write(" = ");
       }
       buffer.write(_defaultValueCode);
     }
   }
 
   @override
+  FormalParameter computeNode() =>
+      getNodeMatching((node) => node is FormalParameter);
+
+  @override
   ElementImpl getChild(String identifier) {
     for (ParameterElement parameter in _parameters) {
       if ((parameter as ParameterElementImpl).identifier == identifier) {
         return parameter as ParameterElementImpl;
       }
     }
     return null;
   }
 
   /**
@@ skipping 64 matching lines @@
   @override
   String get defaultValueCode => baseElement.defaultValueCode;
 
   @override
   Element get enclosingElement => baseElement.enclosingElement;
 
   @override
   bool get isInitializingFormal => baseElement.isInitializingFormal;
 
   @override
-  FormalParameter get node => baseElement.node;
-
-  @override
   ParameterKind get parameterKind => baseElement.parameterKind;
 
   @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     List<ParameterElement> parameterizedParameters =
         new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] =
           ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
 
   @override
   SourceRange get visibleRange => baseElement.visibleRange;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
   @override
+  FormalParameter computeNode() => baseElement.computeNode();
+
+  @override
   Element getAncestor(Predicate<Element> predicate) {
     Element element = baseElement.getAncestor(predicate);
     ParameterizedType definingType = this.definingType;
     if (definingType is InterfaceType) {
       InterfaceType definingInterfaceType = definingType;
       if (element is ConstructorElement) {
         return ConstructorMember.from(element, definingInterfaceType);
       } else if (element is MethodElement) {
         return MethodMember.from(element, definingInterfaceType);
       } else if (element is PropertyAccessorElement) {
@@ skipping 314 matching lines @@
   }
 
   @override
   String get name {
     if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
 
-  @override
-  AstNode get node {
-    if (isSynthetic) {
-      return null;
-    }
-    if (enclosingElement is ClassElement) {
-      return getNodeMatching((node) => node is MethodDeclaration);
-    }
-    if (enclosingElement is CompilationUnitElement) {
-      return getNodeMatching((node) => node is FunctionDeclaration);
-    }
-    return null;
-  }
-
   /**
    * Set whether this accessor is a setter.
    */
   void set setter(bool isSetter) {
     setModifier(Modifier.SETTER, isSetter);
   }
 
   /**
    * Set whether this accessor is static.
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   bool operator ==(Object object) => super == object &&
       isGetter == (object as PropertyAccessorElement).isGetter;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(isGetter ? "get " : "set ");
     buffer.write(variable.displayName);
     super.appendTo(buffer);
   }
+
+  @override
+  AstNode computeNode() {
+    if (isSynthetic) {
+      return null;
+    }
+    if (enclosingElement is ClassElement) {
+      return getNodeMatching((node) => node is MethodDeclaration);
+    }
+    if (enclosingElement is CompilationUnitElement) {
+      return getNodeMatching((node) => node is FunctionDeclaration);
+    }
+    return null;
+  }
 }
 
 /**
  * A property accessor element defined in a parameterized type where the values
  * of the type parameters are known.
  */
 class PropertyAccessorMember extends ExecutableMember
     implements PropertyAccessorElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
@@ skipping 508 matching lines @@
  * A top-level variable.
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {
   /**
    * An empty list of top-level variable elements.
    */
   static const List<TopLevelVariableElement> EMPTY_LIST =
       const <TopLevelVariableElement>[];
 
   @override
-  VariableDeclaration get node;
+  VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [TopLevelVariableElement].
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl
     with PotentiallyConstVariableElement implements TopLevelVariableElement {
   /**
    * An empty list of top-level variable elements.
    */
@@ skipping 13 matching lines @@
    */
   TopLevelVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
   bool get isStatic => true;
 
   @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
 
   @override
-  VariableDeclaration get node =>
-      getNodeMatching((node) => node is VariableDeclaration);
+  accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
 
   @override
-  accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
+  VariableDeclaration computeNode() =>
+      getNodeMatching((node) => node is VariableDeclaration);
 }
 
 /**
  * The abstract class `TypeImpl` implements the behavior common to objects
  * representing the declared type of elements in the element model.
  */
 abstract class TypeImpl implements DartType {
   /**
    * An empty list of types.
    */
@@ skipping 811 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }