Rename Element.node

pkg/analyzer/lib/src/generated/element_handle.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_handle;
 
 import 'ast.dart';
@@ skipping 182 matching lines @@
   List<FunctionTypeAliasElement> get functionTypeAliases =>
       actualElement.functionTypeAliases;
 
   @override
   bool get hasLoadLibraryFunction => actualElement.hasLoadLibraryFunction;
 
   @override
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
 
   @override
-  CompilationUnit get node => actualElement.node;
-
-  @override
   Source get source => actualElement.source;
 
   @override
   List<TopLevelVariableElement> get topLevelVariables =>
       actualElement.topLevelVariables;
 
   @override
   List<ClassElement> get types => actualElement.types;
 
   @override
   String get uri => actualElement.uri;
 
   @override
   int get uriEnd => actualElement.uriEnd;
 
   @override
   int get uriOffset => actualElement.uriOffset;
 
   @override
+  CompilationUnit computeNode() => actualElement.computeNode();
+
+  @override
   Element getElementAt(int offset) {
     return actualElement.getElementAt(offset);
   }
 
   @override
   ClassElement getEnum(String enumName) => actualElement.getEnum(enumName);
 
   @override
   ClassElement getType(String className) => actualElement.getType(className);
 }
@@ skipping 27 matching lines @@
   @override
   bool get isFactory => actualElement.isFactory;
 
   @override
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
   @override
   int get nameEnd => actualElement.nameEnd;
 
   @override
-  ConstructorDeclaration get node => actualElement.node;
-
-  @override
   int get periodOffset => actualElement.periodOffset;
 
   @override
   ConstructorElement get redirectedConstructor =>
       actualElement.redirectedConstructor;
+
+  @override
+  ConstructorDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
  * The abstract class `ElementHandle` implements the behavior common to objects that implement
  * a handle to an [Element].
  */
 abstract class ElementHandle implements Element {
   /**
    * The unique integer identifier of this element.
    */
@@ skipping 78 matching lines @@
 
   @override
   List<ElementAnnotation> get metadata => actualElement.metadata;
 
   @override
   String get name => actualElement.name;
 
   @override
   int get nameOffset => actualElement.nameOffset;
 
+  @deprecated
   @override
-  AstNode get node => actualElement.node;
+  AstNode get node => computeNode();
 
   @override
   Source get source => actualElement.source;
 
   @override
   CompilationUnit get unit => actualElement.unit;
 
   @override
   bool operator ==(Object object) =>
       object is Element && object.location == _location;
 
   @override
   accept(ElementVisitor visitor) => actualElement.accept(visitor);
 
   @override
   String computeDocumentationComment() =>
       actualElement.computeDocumentationComment();
 
   @override
+  AstNode computeNode() => actualElement.computeNode();
+
+  @override
   Element getAncestor(Predicate<Element> predicate) =>
       actualElement.getAncestor(predicate);
 
   @override
   String getExtendedDisplayName(String shortName) =>
       actualElement.getExtendedDisplayName(shortName);
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       actualElement.isAccessibleIn(library);
@@ skipping 189 matching lines @@
   @override
   bool get isEnumConstant => actualElement.isEnumConstant;
 
   @override
   bool get isStatic => actualElement.isStatic;
 
   @override
   ElementKind get kind => ElementKind.FIELD;
 
   @override
-  VariableDeclaration get node => actualElement.node;
+  VariableDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
  * Instances of the class `FunctionElementHandle` implement a handle to a
  * `FunctionElement`.
  */
 class FunctionElementHandle extends ExecutableElementHandle
     implements FunctionElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
    * @param element the element being represented
    */
   FunctionElementHandle(FunctionElement element) : super(element);
 
   @override
   FunctionElement get actualElement => super.actualElement as FunctionElement;
 
   @override
   bool get isEntryPoint => actualElement.isEntryPoint;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
-  FunctionDeclaration get node => actualElement.node;
+  SourceRange get visibleRange => actualElement.visibleRange;
 
   @override
-  SourceRange get visibleRange => actualElement.visibleRange;
+  FunctionDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
  * Instances of the class `FunctionTypeAliasElementHandle` implement a handle to a
  * `FunctionTypeAliasElement`.
  */
 class FunctionTypeAliasElementHandle extends ElementHandle
     implements FunctionTypeAliasElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
    * @param element the element being represented
    */
   FunctionTypeAliasElementHandle(FunctionTypeAliasElement element)
       : super(element);
 
   @override
   FunctionTypeAliasElement get actualElement =>
       super.actualElement as FunctionTypeAliasElement;
 
   @override
   CompilationUnitElement get enclosingElement =>
       super.enclosingElement as CompilationUnitElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
-  FunctionTypeAlias get node => actualElement.node;
-
-  @override
   List<ParameterElement> get parameters => actualElement.parameters;
 
   @override
   DartType get returnType => actualElement.returnType;
 
   @override
   FunctionType get type => actualElement.type;
 
   @override
   List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
+
+  @override
+  FunctionTypeAlias computeNode() => actualElement.computeNode();
 }
 
 /**
  * Instances of the class `ImportElementHandle` implement a handle to an `ImportElement`
  * .
  */
 class ImportElementHandle extends ElementHandle implements ImportElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ skipping 149 matching lines @@
   LocalVariableElementHandle(LocalVariableElement element) : super(element);
 
   @override
   LocalVariableElement get actualElement =>
       super.actualElement as LocalVariableElement;
 
   @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
-  VariableDeclaration get node => actualElement.node;
+  SourceRange get visibleRange => actualElement.visibleRange;
 
   @override
-  SourceRange get visibleRange => actualElement.visibleRange;
+  VariableDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
  * Instances of the class `MethodElementHandle` implement a handle to a `MethodElement`.
  */
 class MethodElementHandle extends ExecutableElementHandle
     implements MethodElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
    * @param element the element being represented
    */
   MethodElementHandle(MethodElement element) : super(element);
 
   @override
   MethodElement get actualElement => super.actualElement as MethodElement;
 
   @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
   bool get isStatic => actualElement.isStatic;
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
-  MethodDeclaration get node => actualElement.node;
+  MethodDeclaration computeNode() => actualElement.computeNode();
 }
 
 /**
  * Instances of the class `ParameterElementHandle` implement a handle to a
  * `ParameterElement`.
  */
 class ParameterElementHandle extends VariableElementHandle
     implements ParameterElement {
   /**
    * Initialize a newly created element handle to represent the given element.
@@ skipping 207 matching lines @@
   DartType get type => actualElement.type;
 }
 /**
  * TODO(scheglov) invalid implementation
  */
 class WeakReference<T> {
   final T value;
   WeakReference(this.value);
   T get() => value;
 }