Reformat

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 101 matching lines @@
 
   @override
   PropertyAccessorElement getSetter(String setterName) =>
       actualElement.getSetter(setterName);
 
   @override
   bool isSuperConstructorAccessible(ConstructorElement constructor) =>
       actualElement.isSuperConstructorAccessible(constructor);
 
   @override
-  MethodElement lookUpConcreteMethod(String methodName,
-      LibraryElement library) =>
+  MethodElement lookUpConcreteMethod(
+          String methodName, LibraryElement library) =>
       actualElement.lookUpConcreteMethod(methodName, library);
 
   @override
-  PropertyAccessorElement lookUpGetter(String getterName,
-      LibraryElement library) =>
+  PropertyAccessorElement lookUpGetter(
+          String getterName, LibraryElement library) =>
       actualElement.lookUpGetter(getterName, library);
 
   @override
-  PropertyAccessorElement lookUpInheritedConcreteGetter(String methodName,
-      LibraryElement library) =>
+  PropertyAccessorElement lookUpInheritedConcreteGetter(
+          String methodName, LibraryElement library) =>
       actualElement.lookUpInheritedConcreteGetter(methodName, library);
 
   @override
-  MethodElement lookUpInheritedConcreteMethod(String methodName,
-      LibraryElement library) =>
+  MethodElement lookUpInheritedConcreteMethod(
+          String methodName, LibraryElement library) =>
       actualElement.lookUpInheritedConcreteMethod(methodName, library);
 
   @override
-  PropertyAccessorElement lookUpInheritedConcreteSetter(String methodName,
-      LibraryElement library) =>
+  PropertyAccessorElement lookUpInheritedConcreteSetter(
+          String methodName, LibraryElement library) =>
       actualElement.lookUpInheritedConcreteSetter(methodName, library);
 
   @override
-  MethodElement lookUpInheritedMethod(String methodName,
-      LibraryElement library) =>
+  MethodElement lookUpInheritedMethod(
+          String methodName, LibraryElement library) =>
       actualElement.lookUpInheritedMethod(methodName, library);
 
   @override
   MethodElement lookUpMethod(String methodName, LibraryElement library) =>
       actualElement.lookUpMethod(methodName, library);
 
   @override
-  PropertyAccessorElement lookUpSetter(String setterName,
-      LibraryElement library) =>
+  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.
    *
    * @param element the element being represented
    */
   CompilationUnitElementHandle(CompilationUnitElement element) : super(element);
 
   @override
   List<PropertyAccessorElement> get accessors => actualElement.accessors;
 
@@ skipping 47 matching lines @@
   ClassElement getEnum(String enumName) => actualElement.getEnum(enumName);
 
   @override
   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.
    *
    * @param element the element being represented
    */
   ConstructorElementHandle(ConstructorElement element) : super(element);
 
   @override
   ConstructorElement get actualElement =>
       super.actualElement as ConstructorElement;
@@ skipping 234 matching lines @@
       handles[i] = forElement(elements[i]);
     }
     return handles;
   }
 }
 
 /**
  * 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.
    *
    * @param element the element being represented
    */
   ExecutableElementHandle(ExecutableElement element) : super(element);
 
   @override
   ExecutableElement get actualElement =>
       super.actualElement as ExecutableElement;
@@ skipping 62 matching lines @@
   @override
   int get uriEnd => actualElement.uriEnd;
 
   @override
   int get uriOffset => actualElement.uriOffset;
 }
 
 /**
  * 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.
    *
    * @param element the element being represented
    */
   FieldElementHandle(FieldElement element) : super(element);
 
   @override
   FieldElement get actualElement => super.actualElement as FieldElement;
 
   @override
   ClassElement get enclosingElement => actualElement.enclosingElement;
 
   @override
   bool get isEnumConstant => actualElement.isEnumConstant;
 
   @override
   bool get isStatic => actualElement.isStatic;
 
   @override
   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.
    *
    * @param element the element being represented
    */
   FunctionElementHandle(FunctionElement element) : super(element);
 
   @override
   FunctionElement get actualElement => super.actualElement as FunctionElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   FunctionDeclaration get node => actualElement.node;
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
 }
 
 /**
  * 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);
 
   @override
   FunctionTypeAliasElement get actualElement =>
@@ skipping 159 matching lines @@
   ClassElement getType(String className) => actualElement.getType(className);
 
   @override
   bool isUpToDate(int timeStamp) => actualElement.isUpToDate(timeStamp);
 }
 
 /**
  * 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.
    *
    * @param element the element being represented
    */
   LocalVariableElementHandle(LocalVariableElement element) : super(element);
 
   @override
   LocalVariableElement get actualElement =>
       super.actualElement as LocalVariableElement;
 
   @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
   SourceRange get visibleRange => actualElement.visibleRange;
 }
 
 /**
  * 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.
    *
    * @param element the element being represented
    */
   MethodElementHandle(MethodElement element) : super(element);
 
   @override
   MethodElement get actualElement => super.actualElement as MethodElement;
 
@@ skipping 10 matching lines @@
   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.
    *
    * @param element the element being represented
    */
   ParameterElementHandle(ParameterElement element) : super(element);
 
   @override
   ParameterElement get actualElement => super.actualElement as ParameterElement;
 
@@ skipping 38 matching lines @@
   List<LibraryElement> get importedLibraries => actualElement.importedLibraries;
 
   @override
   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 actualElement =>
@@ skipping 75 matching lines @@
       : super(element);
 
   @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
 }
 
 /**
  * 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.
    *
    * @param element the element being represented
    */
   TypeParameterElementHandle(TypeParameterElement element) : super(element);
 
   @override
   TypeParameterElement get actualElement =>
       super.actualElement as TypeParameterElement;
 
   @override
   DartType get bound => actualElement.bound;
 
   @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
   TypeParameterType get type => actualElement.type;
 }
 
 /**
  * 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.
    *
    * @param element the element being represented
    */
   VariableElementHandle(VariableElement element) : super(element);
 
   @override
   VariableElement get actualElement => super.actualElement as VariableElement;
 
@@ skipping 13 matching lines @@
   DartType get type => actualElement.type;
 }
 /**
  * TODO(scheglov) invalid implementation
  */
 class WeakReference<T> {
   final T value;
   WeakReference(this.value);
   T get() => value;
 }