Format and sort analyzer and analysis_server packages.

pkg/analyzer/lib/src/generated/element_handle.dart

Index: pkg/analyzer/lib/src/generated/element_handle.dart
diff --git a/pkg/analyzer/lib/src/generated/element_handle.dart b/pkg/analyzer/lib/src/generated/element_handle.dart
index 8f582bb08a366d18e3e9e2c563379cfcb3ffa2b5..61afb897b5ce43ff045caff0961a2d60f4d9966d 100644
--- a/pkg/analyzer/lib/src/generated/element_handle.dart
+++ b/pkg/analyzer/lib/src/generated/element_handle.dart
@@ -10,10 +10,10 @@ library engine.element_handle;
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart';
-import 'source.dart';
-import 'utilities_dart.dart';
 import 'java_core.dart';
 import 'java_engine.dart';
+import 'source.dart';
+import 'utilities_dart.dart';
 
 /**
  * Instances of the class `ClassElementHandle` implement a handle to a `ClassElement`.
@@ -30,123 +30,143 @@ class ClassElementHandle extends ElementHandle implements ClassElement {
   List<PropertyAccessorElement> get accessors => actualElement.accessors;
 
   @override
-  List<InterfaceType> get allSupertypes => actualElement.allSupertypes;
+  ClassElement get actualElement => super.actualElement as ClassElement;
 
   @override
-  List<ConstructorElement> get constructors => actualElement.constructors;
+  List<InterfaceType> get allSupertypes => actualElement.allSupertypes;
 
   @override
-  FieldElement getField(String fieldName) => actualElement.getField(fieldName);
+  List<ConstructorElement> get constructors => actualElement.constructors;
 
   @override
   List<FieldElement> get fields => actualElement.fields;
 
   @override
-  PropertyAccessorElement getGetter(String getterName) => actualElement.getGetter(getterName);
+  bool get hasNonFinalField => actualElement.hasNonFinalField;
 
   @override
-  List<InterfaceType> get interfaces => actualElement.interfaces;
+  bool get hasReferenceToSuper => actualElement.hasReferenceToSuper;
 
   @override
-  ElementKind get kind => ElementKind.CLASS;
+  bool get hasStaticMember => actualElement.hasStaticMember;
 
   @override
-  MethodElement getMethod(String methodName) => actualElement.getMethod(methodName);
+  List<InterfaceType> get interfaces => actualElement.interfaces;
 
   @override
-  List<MethodElement> get methods => actualElement.methods;
+  bool get isAbstract => actualElement.isAbstract;
 
   @override
-  List<InterfaceType> get mixins => actualElement.mixins;
+  bool get isEnum => actualElement.isEnum;
 
   @override
-  ConstructorElement getNamedConstructor(String name) => actualElement.getNamedConstructor(name);
+  bool get isOrInheritsProxy => actualElement.isOrInheritsProxy;
 
   @override
-  ClassDeclaration get node => actualElement.node;
+  bool get isProxy => actualElement.isProxy;
 
   @override
-  PropertyAccessorElement getSetter(String setterName) => actualElement.getSetter(setterName);
+  bool get isTypedef => actualElement.isTypedef;
 
   @override
-  InterfaceType get supertype => actualElement.supertype;
+  bool get isValidMixin => actualElement.isValidMixin;
 
   @override
-  List<ToolkitObjectElement> get toolkitObjects => actualElement.toolkitObjects;
+  ElementKind get kind => ElementKind.CLASS;
 
   @override
-  InterfaceType get type => actualElement.type;
+  List<MethodElement> get methods => actualElement.methods;
 
   @override
-  List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
+  List<InterfaceType> get mixins => actualElement.mixins;
 
   @override
-  ConstructorElement get unnamedConstructor => actualElement.unnamedConstructor;
+  ClassDeclaration get node => actualElement.node;
 
   @override
-  bool get hasNonFinalField => actualElement.hasNonFinalField;
+  InterfaceType get supertype => actualElement.supertype;
 
   @override
-  bool get hasReferenceToSuper => actualElement.hasReferenceToSuper;
+  List<ToolkitObjectElement> get toolkitObjects => actualElement.toolkitObjects;
 
   @override
-  bool get hasStaticMember => actualElement.hasStaticMember;
+  InterfaceType get type => actualElement.type;
 
   @override
-  bool get isAbstract => actualElement.isAbstract;
+  List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
 
   @override
-  bool get isEnum => actualElement.isEnum;
+  ConstructorElement get unnamedConstructor => actualElement.unnamedConstructor;
 
   @override
-  bool get isOrInheritsProxy => actualElement.isOrInheritsProxy;
+  FieldElement getField(String fieldName) => actualElement.getField(fieldName);
 
   @override
-  bool get isProxy => actualElement.isProxy;
+  PropertyAccessorElement getGetter(String getterName) =>
+      actualElement.getGetter(getterName);
 
   @override
-  bool isSuperConstructorAccessible(ConstructorElement constructor) =>
-      actualElement.isSuperConstructorAccessible(constructor);
+  MethodElement getMethod(String methodName) =>
+      actualElement.getMethod(methodName);
 
   @override
-  bool get isTypedef => actualElement.isTypedef;
+  ConstructorElement getNamedConstructor(String name) =>
+      actualElement.getNamedConstructor(name);
 
   @override
-  bool get isValidMixin => actualElement.isValidMixin;
+  PropertyAccessorElement getSetter(String setterName) =>
+      actualElement.getSetter(setterName);
 
   @override
-  MethodElement lookUpConcreteMethod(String methodName, LibraryElement library) => actualElement.lookUpConcreteMethod(methodName, library);
+  bool isSuperConstructorAccessible(ConstructorElement constructor) =>
+      actualElement.isSuperConstructorAccessible(constructor);
 
   @override
-  PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) => actualElement.lookUpGetter(getterName, library);
+  MethodElement lookUpConcreteMethod(String methodName,
+      LibraryElement library) =>
+      actualElement.lookUpConcreteMethod(methodName, library);
 
   @override
-  PropertyAccessorElement lookUpInheritedConcreteGetter(String methodName, LibraryElement library) => actualElement.lookUpInheritedConcreteGetter(methodName, library);
+  PropertyAccessorElement lookUpGetter(String getterName,
+      LibraryElement library) =>
+      actualElement.lookUpGetter(getterName, library);
 
   @override
-  MethodElement lookUpInheritedConcreteMethod(String methodName, LibraryElement library) => actualElement.lookUpInheritedConcreteMethod(methodName, library);
+  PropertyAccessorElement lookUpInheritedConcreteGetter(String methodName,
+      LibraryElement library) =>
+      actualElement.lookUpInheritedConcreteGetter(methodName, library);
 
   @override
-  PropertyAccessorElement lookUpInheritedConcreteSetter(String methodName, LibraryElement library) => actualElement.lookUpInheritedConcreteSetter(methodName, library);
+  MethodElement lookUpInheritedConcreteMethod(String methodName,
+      LibraryElement library) =>
+      actualElement.lookUpInheritedConcreteMethod(methodName, library);
 
   @override
-  MethodElement lookUpInheritedMethod(String methodName, LibraryElement library) => actualElement.lookUpInheritedMethod(methodName, library);
+  PropertyAccessorElement lookUpInheritedConcreteSetter(String methodName,
+      LibraryElement library) =>
+      actualElement.lookUpInheritedConcreteSetter(methodName, library);
 
   @override
-  MethodElement lookUpMethod(String methodName, LibraryElement library) => actualElement.lookUpMethod(methodName, library);
+  MethodElement lookUpInheritedMethod(String methodName,
+      LibraryElement library) =>
+      actualElement.lookUpInheritedMethod(methodName, library);
 
   @override
-  PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) => actualElement.lookUpSetter(setterName, library);
+  MethodElement lookUpMethod(String methodName, LibraryElement library) =>
+      actualElement.lookUpMethod(methodName, library);
 
   @override
-  ClassElement get actualElement => super.actualElement as ClassElement;
+  PropertyAccessorElement lookUpSetter(String setterName,
+      LibraryElement library) =>
+      actualElement.lookUpSetter(setterName, library);
 }
 
 /**
  * Instances of the class `CompilationUnitElementHandle` implements a handle to a
  * [CompilationUnitElement].
  */
-class CompilationUnitElementHandle extends ElementHandle implements CompilationUnitElement {
+class CompilationUnitElementHandle extends ElementHandle implements
+    CompilationUnitElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -158,13 +178,15 @@ class CompilationUnitElementHandle extends ElementHandle implements CompilationU
   List<PropertyAccessorElement> get accessors => actualElement.accessors;
 
   @override
-  List<AngularViewElement> get angularViews => actualElement.angularViews;
+  CompilationUnitElement get actualElement =>
+      super.actualElement as CompilationUnitElement;
 
   @override
-  LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
+  List<AngularViewElement> get angularViews => actualElement.angularViews;
 
   @override
-  ClassElement getEnum(String enumName) => actualElement.getEnum(enumName);
+  LibraryElement get enclosingElement =>
+      super.enclosingElement as LibraryElement;
 
   @override
   List<ClassElement> get enums => actualElement.enums;
@@ -173,7 +195,11 @@ class CompilationUnitElementHandle extends ElementHandle implements CompilationU
   List<FunctionElement> get functions => actualElement.functions;
 
   @override
-  List<FunctionTypeAliasElement> get functionTypeAliases => actualElement.functionTypeAliases;
+  List<FunctionTypeAliasElement> get functionTypeAliases =>
+      actualElement.functionTypeAliases;
+
+  @override
+  bool get hasLoadLibraryFunction => actualElement.hasLoadLibraryFunction;
 
   @override
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
@@ -185,10 +211,8 @@ class CompilationUnitElementHandle extends ElementHandle implements CompilationU
   Source get source => actualElement.source;
 
   @override
-  List<TopLevelVariableElement> get topLevelVariables => actualElement.topLevelVariables;
-
-  @override
-  ClassElement getType(String className) => actualElement.getType(className);
+  List<TopLevelVariableElement> get topLevelVariables =>
+      actualElement.topLevelVariables;
 
   @override
   List<ClassElement> get types => actualElement.types;
@@ -203,17 +227,18 @@ class CompilationUnitElementHandle extends ElementHandle implements CompilationU
   int get uriOffset => actualElement.uriOffset;
 
   @override
-  bool get hasLoadLibraryFunction => actualElement.hasLoadLibraryFunction;
+  ClassElement getEnum(String enumName) => actualElement.getEnum(enumName);
 
   @override
-  CompilationUnitElement get actualElement => super.actualElement as CompilationUnitElement;
+  ClassElement getType(String className) => actualElement.getType(className);
 }
 
 /**
  * Instances of the class `ConstructorElementHandle` implement a handle to a
  * `ConstructorElement`.
  */
-class ConstructorElementHandle extends ExecutableElementHandle implements ConstructorElement {
+class ConstructorElementHandle extends ExecutableElementHandle implements
+    ConstructorElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -222,28 +247,30 @@ class ConstructorElementHandle extends ExecutableElementHandle implements Constr
   ConstructorElementHandle(ConstructorElement element) : super(element);
 
   @override
-  ClassElement get enclosingElement => actualElement.enclosingElement;
+  ConstructorElement get actualElement =>
+      super.actualElement as ConstructorElement;
 
   @override
-  ElementKind get kind => ElementKind.CONSTRUCTOR;
+  ClassElement get enclosingElement => actualElement.enclosingElement;
 
   @override
-  ConstructorDeclaration get node => actualElement.node;
+  bool get isConst => actualElement.isConst;
 
   @override
-  ConstructorElement get redirectedConstructor => actualElement.redirectedConstructor;
+  bool get isDefaultConstructor => actualElement.isDefaultConstructor;
 
   @override
-  bool get isConst => actualElement.isConst;
+  bool get isFactory => actualElement.isFactory;
 
   @override
-  bool get isDefaultConstructor => actualElement.isDefaultConstructor;
+  ElementKind get kind => ElementKind.CONSTRUCTOR;
 
   @override
-  bool get isFactory => actualElement.isFactory;
+  ConstructorDeclaration get node => actualElement.node;
 
   @override
-  ConstructorElement get actualElement => super.actualElement as ConstructorElement;
+  ConstructorElement get redirectedConstructor =>
+      actualElement.redirectedConstructor;
 }
 
 /**
@@ -252,77 +279,6 @@ class ConstructorElementHandle extends ExecutableElementHandle implements Constr
  */
 abstract class ElementHandle implements Element {
   /**
-   * Return a handle on the given element. If the element is already a handle, then it will be
-   * returned directly, otherwise a handle of the appropriate class will be constructed.
-   *
-   * @param element the element for which a handle is to be constructed
-   * @return a handle on the given element
-   */
-  static Element forElement(Element element) {
-    if (element is ElementHandle) {
-      return element;
-    }
-    while (true) {
-      if (element.kind == ElementKind.CLASS) {
-        return new ClassElementHandle(element as ClassElement);
-      } else if (element.kind == ElementKind.COMPILATION_UNIT) {
-        return new CompilationUnitElementHandle(element as CompilationUnitElement);
-      } else if (element.kind == ElementKind.CONSTRUCTOR) {
-        return new ConstructorElementHandle(element as ConstructorElement);
-      } else if (element.kind == ElementKind.EXPORT) {
-        return new ExportElementHandle(element as ExportElement);
-      } else if (element.kind == ElementKind.FIELD) {
-        return new FieldElementHandle(element as FieldElement);
-      } else if (element.kind == ElementKind.FUNCTION) {
-        return new FunctionElementHandle(element as FunctionElement);
-      } else if (element.kind == ElementKind.GETTER) {
-        return new PropertyAccessorElementHandle(element as PropertyAccessorElement);
-      } else if (element.kind == ElementKind.IMPORT) {
-        return new ImportElementHandle(element as ImportElement);
-      } else if (element.kind == ElementKind.LABEL) {
-        return new LabelElementHandle(element as LabelElement);
-      } else if (element.kind == ElementKind.LIBRARY) {
-        return new LibraryElementHandle(element as LibraryElement);
-      } else if (element.kind == ElementKind.LOCAL_VARIABLE) {
-        return new LocalVariableElementHandle(element as LocalVariableElement);
-      } else if (element.kind == ElementKind.METHOD) {
-        return new MethodElementHandle(element as MethodElement);
-      } else if (element.kind == ElementKind.PARAMETER) {
-        return new ParameterElementHandle(element as ParameterElement);
-      } else if (element.kind == ElementKind.PREFIX) {
-        return new PrefixElementHandle(element as PrefixElement);
-      } else if (element.kind == ElementKind.SETTER) {
-        return new PropertyAccessorElementHandle(element as PropertyAccessorElement);
-      } else if (element.kind == ElementKind.TOP_LEVEL_VARIABLE) {
-        return new TopLevelVariableElementHandle(element as TopLevelVariableElement);
-      } else if (element.kind == ElementKind.FUNCTION_TYPE_ALIAS) {
-        return new FunctionTypeAliasElementHandle(element as FunctionTypeAliasElement);
-      } else if (element.kind == ElementKind.TYPE_PARAMETER) {
-        return new TypeParameterElementHandle(element as TypeParameterElement);
-      } else {
-        throw new UnsupportedOperationException();
-      }
-      break;
-    }
-  }
-
-  /**
-   * Return an array of the same size as the given array where each element of the returned array is
-   * a handle for the corresponding element of the given array.
-   *
-   * @param elements the elements for which handles are to be created
-   * @return an array of handles to the given elements
-   */
-  static List<Element> forElements(List<Element> elements) {
-    int length = elements.length;
-    List<Element> handles = new List<Element>.from(elements);
-    for (int i = 0; i < length; i++) {
-      handles[i] = forElement(elements[i]);
-    }
-    return handles;
-  }
-
-  /**
    * The context in which the element is defined.
    */
   AnalysisContext _context;
@@ -350,32 +306,51 @@ abstract class ElementHandle implements Element {
     _elementReference = new WeakReference<Element>(element);
   }
 
+  /**
+   * Return the element being represented by this handle, reconstituting the element if the
+   * reference has been set to `null`.
+   *
+   * @return the element being represented by this handle
+   */
+  Element get actualElement {
+    Element element = _elementReference.get();
+    if (element == null) {
+      element = _context.getElement(_location);
+      _elementReference = new WeakReference<Element>(element);
+    }
+    return element;
+  }
+
   @override
-  accept(ElementVisitor visitor) => actualElement.accept(visitor);
+  AnalysisContext get context => _context;
 
   @override
-  String computeDocumentationComment() => actualElement.computeDocumentationComment();
+  String get displayName => actualElement.displayName;
 
   @override
-  bool operator ==(Object object) => object is Element && object.location == _location;
+  Element get enclosingElement => actualElement.enclosingElement;
 
   @override
-  Element getAncestor(Predicate<Element> predicate) => actualElement.getAncestor(predicate);
+  int get hashCode => _location.hashCode;
 
   @override
-  AnalysisContext get context => _context;
+  bool get isDeprecated => actualElement.isDeprecated;
 
   @override
-  String get displayName => actualElement.displayName;
+  bool get isOverride => actualElement.isOverride;
 
   @override
-  Element get enclosingElement => actualElement.enclosingElement;
+  bool get isPrivate => actualElement.isPrivate;
+
+  @override
+  bool get isPublic => actualElement.isPublic;
 
   @override
-  String getExtendedDisplayName(String shortName) => actualElement.getExtendedDisplayName(shortName);
+  bool get isSynthetic => actualElement.isSynthetic;
 
   @override
-  LibraryElement get library => getAncestor((element) => element is LibraryElement);
+  LibraryElement get library =>
+      getAncestor((element) => element is LibraryElement);
 
   @override
   ElementLocation get location => _location;
@@ -399,25 +374,27 @@ abstract class ElementHandle implements Element {
   CompilationUnit get unit => actualElement.unit;
 
   @override
-  int get hashCode => _location.hashCode;
+  bool operator ==(Object object) =>
+      object is Element && object.location == _location;
 
   @override
-  bool isAccessibleIn(LibraryElement library) => actualElement.isAccessibleIn(library);
+  accept(ElementVisitor visitor) => actualElement.accept(visitor);
 
   @override
-  bool get isDeprecated => actualElement.isDeprecated;
+  String computeDocumentationComment() =>
+      actualElement.computeDocumentationComment();
 
   @override
-  bool get isOverride => actualElement.isOverride;
+  Element getAncestor(Predicate<Element> predicate) =>
+      actualElement.getAncestor(predicate);
 
   @override
-  bool get isPrivate => actualElement.isPrivate;
+  String getExtendedDisplayName(String shortName) =>
+      actualElement.getExtendedDisplayName(shortName);
 
   @override
-  bool get isPublic => actualElement.isPublic;
-
-  @override
-  bool get isSynthetic => actualElement.isSynthetic;
+  bool isAccessibleIn(LibraryElement library) =>
+      actualElement.isAccessibleIn(library);
 
   @override
   void visitChildren(ElementVisitor visitor) {
@@ -425,18 +402,79 @@ abstract class ElementHandle implements Element {
   }
 
   /**
-   * Return the element being represented by this handle, reconstituting the element if the
-   * reference has been set to `null`.
+   * Return a handle on the given element. If the element is already a handle, then it will be
+   * returned directly, otherwise a handle of the appropriate class will be constructed.
    *
-   * @return the element being represented by this handle
+   * @param element the element for which a handle is to be constructed
+   * @return a handle on the given element
    */
-  Element get actualElement {
-    Element element = _elementReference.get();
-    if (element == null) {
-      element = _context.getElement(_location);
-      _elementReference = new WeakReference<Element>(element);
+  static Element forElement(Element element) {
+    if (element is ElementHandle) {
+      return element;
+    }
+    while (true) {
+      if (element.kind == ElementKind.CLASS) {
+        return new ClassElementHandle(element as ClassElement);
+      } else if (element.kind == ElementKind.COMPILATION_UNIT) {
+        return new CompilationUnitElementHandle(
+            element as CompilationUnitElement);
+      } else if (element.kind == ElementKind.CONSTRUCTOR) {
+        return new ConstructorElementHandle(element as ConstructorElement);
+      } else if (element.kind == ElementKind.EXPORT) {
+        return new ExportElementHandle(element as ExportElement);
+      } else if (element.kind == ElementKind.FIELD) {
+        return new FieldElementHandle(element as FieldElement);
+      } else if (element.kind == ElementKind.FUNCTION) {
+        return new FunctionElementHandle(element as FunctionElement);
+      } else if (element.kind == ElementKind.GETTER) {
+        return new PropertyAccessorElementHandle(
+            element as PropertyAccessorElement);
+      } else if (element.kind == ElementKind.IMPORT) {
+        return new ImportElementHandle(element as ImportElement);
+      } else if (element.kind == ElementKind.LABEL) {
+        return new LabelElementHandle(element as LabelElement);
+      } else if (element.kind == ElementKind.LIBRARY) {
+        return new LibraryElementHandle(element as LibraryElement);
+      } else if (element.kind == ElementKind.LOCAL_VARIABLE) {
+        return new LocalVariableElementHandle(element as LocalVariableElement);
+      } else if (element.kind == ElementKind.METHOD) {
+        return new MethodElementHandle(element as MethodElement);
+      } else if (element.kind == ElementKind.PARAMETER) {
+        return new ParameterElementHandle(element as ParameterElement);
+      } else if (element.kind == ElementKind.PREFIX) {
+        return new PrefixElementHandle(element as PrefixElement);
+      } else if (element.kind == ElementKind.SETTER) {
+        return new PropertyAccessorElementHandle(
+            element as PropertyAccessorElement);
+      } else if (element.kind == ElementKind.TOP_LEVEL_VARIABLE) {
+        return new TopLevelVariableElementHandle(
+            element as TopLevelVariableElement);
+      } else if (element.kind == ElementKind.FUNCTION_TYPE_ALIAS) {
+        return new FunctionTypeAliasElementHandle(
+            element as FunctionTypeAliasElement);
+      } else if (element.kind == ElementKind.TYPE_PARAMETER) {
+        return new TypeParameterElementHandle(element as TypeParameterElement);
+      } else {
+        throw new UnsupportedOperationException();
+      }
+      break;
     }
-    return element;
+  }
+
+  /**
+   * Return an array of the same size as the given array where each element of the returned array is
+   * a handle for the corresponding element of the given array.
+   *
+   * @param elements the elements for which handles are to be created
+   * @return an array of handles to the given elements
+   */
+  static List<Element> forElements(List<Element> elements) {
+    int length = elements.length;
+    List<Element> handles = new List<Element>.from(elements);
+    for (int i = 0; i < length; i++) {
+      handles[i] = forElement(elements[i]);
+    }
+    return handles;
   }
 }
 
@@ -444,7 +482,8 @@ abstract class ElementHandle implements Element {
  * The abstract class `ExecutableElementHandle` implements the behavior common to objects that
  * implement a handle to an [ExecutableElement].
  */
-abstract class ExecutableElementHandle extends ElementHandle implements ExecutableElement {
+abstract class ExecutableElementHandle extends ElementHandle implements
+    ExecutableElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -453,40 +492,41 @@ abstract class ExecutableElementHandle extends ElementHandle implements Executab
   ExecutableElementHandle(ExecutableElement element) : super(element);
 
   @override
-  List<FunctionElement> get functions => actualElement.functions;
+  ExecutableElement get actualElement =>
+      super.actualElement as ExecutableElement;
 
   @override
-  List<LabelElement> get labels => actualElement.labels;
+  List<FunctionElement> get functions => actualElement.functions;
 
   @override
-  List<LocalVariableElement> get localVariables => actualElement.localVariables;
+  bool get isAsynchronous => actualElement.isAsynchronous;
 
   @override
-  List<ParameterElement> get parameters => actualElement.parameters;
+  bool get isGenerator => actualElement.isGenerator;
 
   @override
-  DartType get returnType => actualElement.returnType;
+  bool get isOperator => actualElement.isOperator;
 
   @override
-  FunctionType get type => actualElement.type;
+  bool get isStatic => actualElement.isStatic;
 
   @override
-  bool get isAsynchronous => actualElement.isAsynchronous;
+  bool get isSynchronous => actualElement.isSynchronous;
 
   @override
-  bool get isGenerator => actualElement.isGenerator;
+  List<LabelElement> get labels => actualElement.labels;
 
   @override
-  bool get isOperator => actualElement.isOperator;
+  List<LocalVariableElement> get localVariables => actualElement.localVariables;
 
   @override
-  bool get isStatic => actualElement.isStatic;
+  List<ParameterElement> get parameters => actualElement.parameters;
 
   @override
-  bool get isSynchronous => actualElement.isSynchronous;
+  DartType get returnType => actualElement.returnType;
 
   @override
-  ExecutableElement get actualElement => super.actualElement as ExecutableElement;
+  FunctionType get type => actualElement.type;
 }
 
 /**
@@ -502,6 +542,9 @@ class ExportElementHandle extends ElementHandle implements ExportElement {
   ExportElementHandle(ExportElement element) : super(element);
 
   @override
+  ExportElement get actualElement => super.actualElement as ExportElement;
+
+  @override
   List<NamespaceCombinator> get combinators => actualElement.combinators;
 
   @override
@@ -518,15 +561,13 @@ class ExportElementHandle extends ElementHandle implements ExportElement {
 
   @override
   int get uriOffset => actualElement.uriOffset;
-
-  @override
-  ExportElement get actualElement => super.actualElement as ExportElement;
 }
 
 /**
  * Instances of the class `FieldElementHandle` implement a handle to a `FieldElement`.
  */
-class FieldElementHandle extends PropertyInducingElementHandle implements FieldElement {
+class FieldElementHandle extends PropertyInducingElementHandle implements
+    FieldElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -535,23 +576,24 @@ class FieldElementHandle extends PropertyInducingElementHandle implements FieldE
   FieldElementHandle(FieldElement element) : super(element);
 
   @override
-  ClassElement get enclosingElement => actualElement.enclosingElement;
+  FieldElement get actualElement => super.actualElement as FieldElement;
 
   @override
-  ElementKind get kind => ElementKind.FIELD;
+  ClassElement get enclosingElement => actualElement.enclosingElement;
 
   @override
   bool get isStatic => actualElement.isStatic;
 
   @override
-  FieldElement get actualElement => super.actualElement as FieldElement;
+  ElementKind get kind => ElementKind.FIELD;
 }
 
 /**
  * Instances of the class `FunctionElementHandle` implement a handle to a
  * `FunctionElement`.
  */
-class FunctionElementHandle extends ExecutableElementHandle implements FunctionElement {
+class FunctionElementHandle extends ExecutableElementHandle implements
+    FunctionElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -560,6 +602,9 @@ class FunctionElementHandle extends ExecutableElementHandle implements FunctionE
   FunctionElementHandle(FunctionElement element) : super(element);
 
   @override
+  FunctionElement get actualElement => super.actualElement as FunctionElement;
+
+  @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
@@ -567,25 +612,29 @@ class FunctionElementHandle extends ExecutableElementHandle implements FunctionE
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
-
-  @override
-  FunctionElement get actualElement => super.actualElement as FunctionElement;
 }
 
 /**
  * Instances of the class `FunctionTypeAliasElementHandle` implement a handle to a
  * `FunctionTypeAliasElement`.
  */
-class FunctionTypeAliasElementHandle extends ElementHandle implements 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);
+  FunctionTypeAliasElementHandle(FunctionTypeAliasElement element)
+      : super(element);
+
+  @override
+  FunctionTypeAliasElement get actualElement =>
+      super.actualElement as FunctionTypeAliasElement;
 
   @override
-  CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
+  CompilationUnitElement get enclosingElement =>
+      super.enclosingElement as CompilationUnitElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
@@ -604,9 +653,6 @@ class FunctionTypeAliasElementHandle extends ElementHandle implements FunctionTy
 
   @override
   List<TypeParameterElement> get typeParameters => actualElement.typeParameters;
-
-  @override
-  FunctionTypeAliasElement get actualElement => super.actualElement as FunctionTypeAliasElement;
 }
 
 /**
@@ -622,12 +668,18 @@ class ImportElementHandle extends ElementHandle implements ImportElement {
   ImportElementHandle(ImportElement element) : super(element);
 
   @override
+  ImportElement get actualElement => super.actualElement as ImportElement;
+
+  @override
   List<NamespaceCombinator> get combinators => actualElement.combinators;
 
   @override
   LibraryElement get importedLibrary => actualElement.importedLibrary;
 
   @override
+  bool get isDeferred => actualElement.isDeferred;
+
+  @override
   ElementKind get kind => ElementKind.IMPORT;
 
   @override
@@ -644,12 +696,6 @@ class ImportElementHandle extends ElementHandle implements ImportElement {
 
   @override
   int get uriOffset => actualElement.uriOffset;
-
-  @override
-  bool get isDeferred => actualElement.isDeferred;
-
-  @override
-  ImportElement get actualElement => super.actualElement as ImportElement;
 }
 
 /**
@@ -664,7 +710,8 @@ class LabelElementHandle extends ElementHandle implements LabelElement {
   LabelElementHandle(LabelElement element) : super(element);
 
   @override
-  ExecutableElement get enclosingElement => super.enclosingElement as ExecutableElement;
+  ExecutableElement get enclosingElement =>
+      super.enclosingElement as ExecutableElement;
 
   @override
   ElementKind get kind => ElementKind.LABEL;
@@ -683,7 +730,11 @@ class LibraryElementHandle extends ElementHandle implements LibraryElement {
   LibraryElementHandle(LibraryElement element) : super(element);
 
   @override
-  CompilationUnitElement get definingCompilationUnit => actualElement.definingCompilationUnit;
+  LibraryElement get actualElement => super.actualElement as LibraryElement;
+
+  @override
+  CompilationUnitElement get definingCompilationUnit =>
+      actualElement.definingCompilationUnit;
 
   @override
   FunctionElement get entryPoint => actualElement.entryPoint;
@@ -695,65 +746,64 @@ class LibraryElementHandle extends ElementHandle implements LibraryElement {
   List<ExportElement> get exports => actualElement.exports;
 
   @override
-  List<LibraryElement> get importedLibraries => actualElement.importedLibraries;
+  bool get hasExtUri => actualElement.hasExtUri;
 
   @override
-  List<ImportElement> get imports => actualElement.imports;
+  bool get hasLoadLibraryFunction => actualElement.hasLoadLibraryFunction;
 
   @override
-  List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) => actualElement.getImportsWithPrefix(prefixElement);
+  List<LibraryElement> get importedLibraries => actualElement.importedLibraries;
 
   @override
-  ElementKind get kind => ElementKind.LIBRARY;
+  List<ImportElement> get imports => actualElement.imports;
 
   @override
-  FunctionElement get loadLibraryFunction => actualElement.loadLibraryFunction;
+  bool get isAngularHtml => actualElement.isAngularHtml;
 
   @override
-  List<CompilationUnitElement> get parts => actualElement.parts;
+  bool get isBrowserApplication => actualElement.isBrowserApplication;
 
   @override
-  List<PrefixElement> get prefixes => actualElement.prefixes;
+  bool get isDartCore => actualElement.isDartCore;
 
   @override
-  ClassElement getType(String className) => actualElement.getType(className);
+  bool get isInSdk => actualElement.isInSdk;
 
   @override
-  List<CompilationUnitElement> get units => actualElement.units;
+  ElementKind get kind => ElementKind.LIBRARY;
 
   @override
-  List<LibraryElement> get visibleLibraries => actualElement.visibleLibraries;
+  FunctionElement get loadLibraryFunction => actualElement.loadLibraryFunction;
 
   @override
-  bool get hasExtUri => actualElement.hasExtUri;
+  List<CompilationUnitElement> get parts => actualElement.parts;
 
   @override
-  bool get hasLoadLibraryFunction => actualElement.hasLoadLibraryFunction;
+  List<PrefixElement> get prefixes => actualElement.prefixes;
 
   @override
-  bool get isAngularHtml => actualElement.isAngularHtml;
+  List<CompilationUnitElement> get units => actualElement.units;
 
   @override
-  bool get isBrowserApplication => actualElement.isBrowserApplication;
+  List<LibraryElement> get visibleLibraries => actualElement.visibleLibraries;
 
   @override
-  bool get isDartCore => actualElement.isDartCore;
+  List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) =>
+      actualElement.getImportsWithPrefix(prefixElement);
 
   @override
-  bool get isInSdk => actualElement.isInSdk;
+  ClassElement getType(String className) => actualElement.getType(className);
 
   @override
   bool isUpToDate(int timeStamp) => actualElement.isUpToDate(timeStamp);
-
-  @override
-  LibraryElement get actualElement => super.actualElement as LibraryElement;
 }
 
 /**
  * Instances of the class `LocalVariableElementHandle` implement a handle to a
  * `LocalVariableElement`.
  */
-class LocalVariableElementHandle extends VariableElementHandle implements LocalVariableElement {
+class LocalVariableElementHandle extends VariableElementHandle implements
+    LocalVariableElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -762,6 +812,10 @@ class LocalVariableElementHandle extends VariableElementHandle implements LocalV
   LocalVariableElementHandle(LocalVariableElement element) : super(element);
 
   @override
+  LocalVariableElement get actualElement =>
+      super.actualElement as LocalVariableElement;
+
+  @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
@@ -769,15 +823,13 @@ class LocalVariableElementHandle extends VariableElementHandle implements LocalV
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
-
-  @override
-  LocalVariableElement get actualElement => super.actualElement as LocalVariableElement;
 }
 
 /**
  * Instances of the class `MethodElementHandle` implement a handle to a `MethodElement`.
  */
-class MethodElementHandle extends ExecutableElementHandle implements MethodElement {
+class MethodElementHandle extends ExecutableElementHandle implements
+    MethodElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -786,13 +838,10 @@ class MethodElementHandle extends ExecutableElementHandle implements MethodEleme
   MethodElementHandle(MethodElement element) : super(element);
 
   @override
-  ClassElement get enclosingElement => super.enclosingElement as ClassElement;
-
-  @override
-  ElementKind get kind => ElementKind.METHOD;
+  MethodElement get actualElement => super.actualElement as MethodElement;
 
   @override
-  MethodDeclaration get node => actualElement.node;
+  ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
   bool get isAbstract => actualElement.isAbstract;
@@ -801,14 +850,18 @@ class MethodElementHandle extends ExecutableElementHandle implements MethodEleme
   bool get isStatic => actualElement.isStatic;
 
   @override
-  MethodElement get actualElement => super.actualElement as MethodElement;
+  ElementKind get kind => ElementKind.METHOD;
+
+  @override
+  MethodDeclaration get node => actualElement.node;
 }
 
 /**
  * Instances of the class `ParameterElementHandle` implement a handle to a
  * `ParameterElement`.
  */
-class ParameterElementHandle extends VariableElementHandle implements ParameterElement {
+class ParameterElementHandle extends VariableElementHandle implements
+    ParameterElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -817,9 +870,15 @@ class ParameterElementHandle extends VariableElementHandle implements ParameterE
   ParameterElementHandle(ParameterElement element) : super(element);
 
   @override
+  ParameterElement get actualElement => super.actualElement as ParameterElement;
+
+  @override
   String get defaultValueCode => actualElement.defaultValueCode;
 
   @override
+  bool get isInitializingFormal => actualElement.isInitializingFormal;
+
+  @override
   ElementKind get kind => ElementKind.PARAMETER;
 
   @override
@@ -830,12 +889,6 @@ class ParameterElementHandle extends VariableElementHandle implements ParameterE
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
-
-  @override
-  bool get isInitializingFormal => actualElement.isInitializingFormal;
-
-  @override
-  ParameterElement get actualElement => super.actualElement as ParameterElement;
 }
 
 /**
@@ -850,47 +903,44 @@ class PrefixElementHandle extends ElementHandle implements PrefixElement {
   PrefixElementHandle(PrefixElement element) : super(element);
 
   @override
-  LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
+  PrefixElement get actualElement => super.actualElement as PrefixElement;
 
   @override
-  List<LibraryElement> get importedLibraries => actualElement.importedLibraries;
+  LibraryElement get enclosingElement =>
+      super.enclosingElement as LibraryElement;
 
   @override
-  ElementKind get kind => ElementKind.PREFIX;
+  List<LibraryElement> get importedLibraries => actualElement.importedLibraries;
 
   @override
-  PrefixElement get actualElement => super.actualElement as PrefixElement;
+  ElementKind get kind => ElementKind.PREFIX;
 }
 
 /**
  * Instances of the class `PropertyAccessorElementHandle` implement a handle to a
  * `PropertyAccessorElement`.
  */
-class PropertyAccessorElementHandle extends ExecutableElementHandle implements PropertyAccessorElement {
+class PropertyAccessorElementHandle extends ExecutableElementHandle implements
+    PropertyAccessorElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
    * @param element the element being represented
    */
-  PropertyAccessorElementHandle(PropertyAccessorElement element) : super(element);
-
-  @override
-  PropertyAccessorElement get correspondingGetter => actualElement.correspondingGetter;
+  PropertyAccessorElementHandle(PropertyAccessorElement element)
+      : super(element);
 
   @override
-  PropertyAccessorElement get correspondingSetter => actualElement.correspondingSetter;
+  PropertyAccessorElement get actualElement =>
+      super.actualElement as PropertyAccessorElement;
 
   @override
-  ElementKind get kind {
-    if (isGetter) {
-      return ElementKind.GETTER;
-    } else {
-      return ElementKind.SETTER;
-    }
-  }
+  PropertyAccessorElement get correspondingGetter =>
+      actualElement.correspondingGetter;
 
   @override
-  PropertyInducingElement get variable => actualElement.variable;
+  PropertyAccessorElement get correspondingSetter =>
+      actualElement.correspondingSetter;
 
   @override
   bool get isAbstract => actualElement.isAbstract;
@@ -902,48 +952,62 @@ class PropertyAccessorElementHandle extends ExecutableElementHandle implements P
   bool get isSetter => actualElement.isSetter;
 
   @override
-  PropertyAccessorElement get actualElement => super.actualElement as PropertyAccessorElement;
+  ElementKind get kind {
+    if (isGetter) {
+      return ElementKind.GETTER;
+    } else {
+      return ElementKind.SETTER;
+    }
+  }
+
+  @override
+  PropertyInducingElement get variable => actualElement.variable;
 }
 
 /**
  * The abstract class `PropertyInducingElementHandle` implements the behavior common to
  * objects that implement a handle to an `PropertyInducingElement`.
  */
-abstract class PropertyInducingElementHandle extends VariableElementHandle implements PropertyInducingElement {
+abstract class PropertyInducingElementHandle extends VariableElementHandle
+    implements PropertyInducingElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
    * @param element the element being represented
    */
-  PropertyInducingElementHandle(PropertyInducingElement element) : super(element);
+  PropertyInducingElementHandle(PropertyInducingElement element)
+      : super(element);
 
   @override
-  PropertyAccessorElement get getter => actualElement.getter;
+  PropertyInducingElement get actualElement =>
+      super.actualElement as PropertyInducingElement;
 
   @override
-  DartType get propagatedType => actualElement.propagatedType;
+  PropertyAccessorElement get getter => actualElement.getter;
 
   @override
-  PropertyAccessorElement get setter => actualElement.setter;
+  bool get isStatic => actualElement.isStatic;
 
   @override
-  bool get isStatic => actualElement.isStatic;
+  DartType get propagatedType => actualElement.propagatedType;
 
   @override
-  PropertyInducingElement get actualElement => super.actualElement as PropertyInducingElement;
+  PropertyAccessorElement get setter => actualElement.setter;
 }
 
 /**
  * Instances of the class `TopLevelVariableElementHandle` implement a handle to a
  * `TopLevelVariableElement`.
  */
-class TopLevelVariableElementHandle extends PropertyInducingElementHandle implements TopLevelVariableElement {
+class TopLevelVariableElementHandle extends PropertyInducingElementHandle
+    implements TopLevelVariableElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
    * @param element the element being represented
    */
-  TopLevelVariableElementHandle(TopLevelVariableElement element) : super(element);
+  TopLevelVariableElementHandle(TopLevelVariableElement element)
+      : super(element);
 
   @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
@@ -953,7 +1017,8 @@ class TopLevelVariableElementHandle extends PropertyInducingElementHandle implem
  * Instances of the class `TypeParameterElementHandle` implement a handle to a
  * [TypeParameterElement].
  */
-class TypeParameterElementHandle extends ElementHandle implements TypeParameterElement {
+class TypeParameterElementHandle extends ElementHandle implements
+    TypeParameterElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -962,6 +1027,10 @@ class TypeParameterElementHandle extends ElementHandle implements TypeParameterE
   TypeParameterElementHandle(TypeParameterElement element) : super(element);
 
   @override
+  TypeParameterElement get actualElement =>
+      super.actualElement as TypeParameterElement;
+
+  @override
   DartType get bound => actualElement.bound;
 
   @override
@@ -969,16 +1038,14 @@ class TypeParameterElementHandle extends ElementHandle implements TypeParameterE
 
   @override
   TypeParameterType get type => actualElement.type;
-
-  @override
-  TypeParameterElement get actualElement => super.actualElement as TypeParameterElement;
 }
 
 /**
  * The abstract class `VariableElementHandle` implements the behavior common to objects that
  * implement a handle to an `VariableElement`.
  */
-abstract class VariableElementHandle extends ElementHandle implements VariableElement {
+abstract class VariableElementHandle extends ElementHandle implements
+    VariableElement {
   /**
    * Initialize a newly created element handle to represent the given element.
    *
@@ -987,13 +1054,10 @@ abstract class VariableElementHandle extends ElementHandle implements VariableEl
   VariableElementHandle(VariableElement element) : super(element);
 
   @override
-  FunctionElement get initializer => actualElement.initializer;
-
-  @override
-  VariableDeclaration get node => actualElement.node;
+  VariableElement get actualElement => super.actualElement as VariableElement;
 
   @override
-  DartType get type => actualElement.type;
+  FunctionElement get initializer => actualElement.initializer;
 
   @override
   bool get isConst => actualElement.isConst;
@@ -1002,7 +1066,10 @@ abstract class VariableElementHandle extends ElementHandle implements VariableEl
   bool get isFinal => actualElement.isFinal;
 
   @override
-  VariableElement get actualElement => super.actualElement as VariableElement;
+  VariableDeclaration get node => actualElement.node;
+
+  @override
+  DartType get type => actualElement.type;
 }
 /**
  * TODO(scheglov) invalid implementation