Reformat

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';
 
 import 'package:analyzer/src/generated/utilities_general.dart';
 
 import 'ast.dart';
 import 'constant.dart' show EvaluationResultImpl;
 import 'engine.dart' show AnalysisContext, AnalysisEngine, AnalysisException;
 import 'html.dart' show XmlAttributeNode, XmlTagNode;
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'resolver.dart';
 import 'scanner.dart' show Keyword;
 import 'sdk.dart' show DartSdk;
 import 'source.dart';
 import 'utilities_collection.dart';
 import 'utilities_dart.dart';
 
-
 /**
  * For AST nodes that could be in both the getter and setter contexts ([IndexExpression]s and
  * [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
  * [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
  * using propagated type information, this class is a wrapper for a pair of
  * [ExecutableElement]s, not just a single [ExecutableElement].
  */
 class AuxiliaryElements {
   /**
    * The element based on propagated type information, or `null` if the AST structure has not
@@ skipping 48 matching lines @@
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       identical(object, this);
 
   @override
   int internalHashCode(List<DartType> visitedTypes) => hashCode;
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
-      Set<TypeImpl_TypePair> visitedTypePairs) =>
-      true;
+      Set<TypeImpl_TypePair> visitedTypePairs) => true;
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) =>
-      true;
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 
   @override
   bool isSupertypeOf(DartType type) => false;
 
   @override
-  BottomTypeImpl substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) =>
-      this;
+  BottomTypeImpl substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }
 
 /**
  * The interface `ClassElement` defines the behavior of elements that represent a class.
  */
 abstract class ClassElement implements Element {
   /**
    * Return an array containing all of the accessors (getters and setters) declared in this class.
    *
    * @return the accessors declared in this class
@@ skipping 256 matching lines @@
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpGetter(String getterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpGetter(
+      String getterName, LibraryElement library);
 
   /**
    * Return the element representing the getter that results from looking up the given getter in the
    * superclass of this class with respect to the given library, ignoring abstract getters, or
    * `null` if the look up fails. The behavior of this method is defined by the Dart Language
    * Specification in section 12.15.1: <blockquote>The result of looking up getter (respectively
    * setter) <i>m</i> in class <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpInheritedConcreteGetter(String getterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpInheritedConcreteGetter(
+      String getterName, LibraryElement library);
 
   /**
    * Return the element representing the method that results from looking up the given method in the
    * superclass of this class with respect to the given library, ignoring abstract methods, or
    * `null` if the look up fails. The behavior of this method is defined by the Dart Language
    * Specification in section 12.15.1: <blockquote> The result of looking up method <i>m</i> in
    * class <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param methodName the name of the method being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given method in the superclass of this class with respect
    *         to the given library
    */
-  MethodElement lookUpInheritedConcreteMethod(String methodName,
-      LibraryElement library);
+  MethodElement lookUpInheritedConcreteMethod(
+      String methodName, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the given setter in the
    * superclass of this class with respect to the given library, ignoring abstract setters, or
    * `null` if the look up fails. The behavior of this method is defined by the Dart Language
    * Specification in section 12.16: <blockquote> The result of looking up getter (respectively
    * setter) <i>m</i> in class <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param setterName the name of the setter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given setter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpInheritedConcreteSetter(String setterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpInheritedConcreteSetter(
+      String setterName, LibraryElement library);
 
   /**
    * Return the element representing the method that results from looking up the given method in the
    * superclass of this class with respect to the given library, or `null` if the look up
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.15.1: <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect
    * to library <i>L</i> is:
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param methodName the name of the method being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given method in the superclass of this class with respect
    *         to the given library
    */
-  MethodElement lookUpInheritedMethod(String methodName,
-      LibraryElement library);
+  MethodElement lookUpInheritedMethod(
+      String methodName, LibraryElement library);
 
   /**
    * Return the element representing the method that results from looking up the given method in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect to library
    * <i>L</i> is:
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
@@ skipping 18 matching lines @@
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param setterName the name of the setter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given setter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpSetter(String setterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpSetter(
+      String setterName, LibraryElement library);
 }
 
 /**
  * Instances of the class `ClassElementImpl` implement a `ClassElement`.
  */
 class ClassElementImpl extends ElementImpl implements ClassElement {
   /**
    * An empty list of class elements.
    */
   static const List<ClassElement> EMPTY_ARRAY = const <ClassElement>[];
@@ skipping 425 matching lines @@
     // accessible (see dartbug.com/19576).
     for (ParameterElement parameter in constructor.parameters) {
       if (parameter.parameterKind != ParameterKind.REQUIRED) {
         return false;
       }
     }
     return true;
   }
 
   @override
-  MethodElement lookUpConcreteMethod(String methodName,
-      LibraryElement library) =>
+  MethodElement lookUpConcreteMethod(
+          String methodName, LibraryElement library) =>
       _internalLookUpConcreteMethod(methodName, library, true);
 
   @override
-  PropertyAccessorElement lookUpGetter(String getterName,
-      LibraryElement library) =>
+  PropertyAccessorElement lookUpGetter(
+          String getterName, LibraryElement library) =>
       _internalLookUpGetter(getterName, library, true);
 
   @override
-  PropertyAccessorElement lookUpInheritedConcreteGetter(String getterName,
-      LibraryElement library) =>
+  PropertyAccessorElement lookUpInheritedConcreteGetter(
+          String getterName, LibraryElement library) =>
       _internalLookUpConcreteGetter(getterName, library, false);
 
   @override
-  MethodElement lookUpInheritedConcreteMethod(String methodName,
-      LibraryElement library) =>
+  MethodElement lookUpInheritedConcreteMethod(
+          String methodName, LibraryElement library) =>
       _internalLookUpConcreteMethod(methodName, library, false);
 
   @override
-  PropertyAccessorElement lookUpInheritedConcreteSetter(String setterName,
-      LibraryElement library) =>
+  PropertyAccessorElement lookUpInheritedConcreteSetter(
+          String setterName, LibraryElement library) =>
       _internalLookUpConcreteSetter(setterName, library, false);
 
   @override
-  MethodElement lookUpInheritedMethod(String methodName,
-      LibraryElement library) =>
+  MethodElement lookUpInheritedMethod(
+          String methodName, LibraryElement library) =>
       _internalLookUpMethod(methodName, library, false);
 
   @override
   MethodElement lookUpMethod(String methodName, LibraryElement library) =>
       _internalLookUpMethod(methodName, library, true);
 
   @override
-  PropertyAccessorElement lookUpSetter(String setterName,
-      LibraryElement library) =>
+  PropertyAccessorElement lookUpSetter(
+          String setterName, LibraryElement library) =>
       _internalLookUpSetter(setterName, library, true);
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
     safelyVisitChildren(_typeParameters, visitor);
@@ skipping 21 matching lines @@
         for (InterfaceType type in currentElement.mixins) {
           ClassElement element = type.element;
           if (!visitedClasses.contains(element)) {
             supertypes.add(type);
           }
         }
       }
     }
   }
 
-  PropertyAccessorElement _internalLookUpConcreteGetter(String getterName,
-      LibraryElement library, bool includeThisClass) {
+  PropertyAccessorElement _internalLookUpConcreteGetter(
+      String getterName, LibraryElement library, bool includeThisClass) {
     PropertyAccessorElement getter =
         _internalLookUpGetter(getterName, library, includeThisClass);
     while (getter != null && getter.isAbstract) {
       Element definingClass = getter.enclosingElement;
       if (definingClass is! ClassElementImpl) {
         return null;
       }
       getter = (definingClass as ClassElementImpl)._internalLookUpGetter(
-          getterName,
-          library,
-          false);
+          getterName, library, false);
     }
     return getter;
   }
 
-  MethodElement _internalLookUpConcreteMethod(String methodName,
-      LibraryElement library, bool includeThisClass) {
+  MethodElement _internalLookUpConcreteMethod(
+      String methodName, LibraryElement library, bool includeThisClass) {
     MethodElement method =
         _internalLookUpMethod(methodName, library, includeThisClass);
     while (method != null && method.isAbstract) {
       ClassElement definingClass = method.enclosingElement;
       if (definingClass == null) {
         return null;
       }
       method = definingClass.lookUpInheritedMethod(methodName, library);
     }
     return method;
   }
 
-  PropertyAccessorElement _internalLookUpConcreteSetter(String setterName,
-      LibraryElement library, bool includeThisClass) {
+  PropertyAccessorElement _internalLookUpConcreteSetter(
+      String setterName, LibraryElement library, bool includeThisClass) {
     PropertyAccessorElement setter =
         _internalLookUpSetter(setterName, library, includeThisClass);
     while (setter != null && setter.isAbstract) {
       Element definingClass = setter.enclosingElement;
       if (definingClass is! ClassElementImpl) {
         return null;
       }
       setter = (definingClass as ClassElementImpl)._internalLookUpSetter(
-          setterName,
-          library,
-          false);
+          setterName, library, false);
     }
     return setter;
   }
 
-  PropertyAccessorElement _internalLookUpGetter(String getterName,
-      LibraryElement library, bool includeThisClass) {
+  PropertyAccessorElement _internalLookUpGetter(
+      String getterName, LibraryElement library, bool includeThisClass) {
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     ClassElement currentElement = this;
     if (includeThisClass) {
       PropertyAccessorElement element = currentElement.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     while (currentElement != null && visitedClasses.add(currentElement)) {
       for (InterfaceType mixin in currentElement.mixins.reversed) {
@@ skipping 11 matching lines @@
       }
       currentElement = supertype.element;
       PropertyAccessorElement element = currentElement.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     return null;
   }
 
-  MethodElement _internalLookUpMethod(String methodName, LibraryElement library,
-      bool includeThisClass) {
+  MethodElement _internalLookUpMethod(
+      String methodName, LibraryElement library, bool includeThisClass) {
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     ClassElement currentElement = this;
     if (includeThisClass) {
       MethodElement element = currentElement.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     while (currentElement != null && visitedClasses.add(currentElement)) {
       for (InterfaceType mixin in currentElement.mixins.reversed) {
@@ skipping 11 matching lines @@
       }
       currentElement = supertype.element;
       MethodElement element = currentElement.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     return null;
   }
 
-  PropertyAccessorElement _internalLookUpSetter(String setterName,
-      LibraryElement library, bool includeThisClass) {
+  PropertyAccessorElement _internalLookUpSetter(
+      String setterName, LibraryElement library, bool includeThisClass) {
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     ClassElement currentElement = this;
     if (includeThisClass) {
       PropertyAccessorElement element = currentElement.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     while (currentElement != null && visitedClasses.add(currentElement)) {
       for (InterfaceType mixin in currentElement.mixins.reversed) {
@@ skipping 11 matching lines @@
       }
       currentElement = supertype.element;
       PropertyAccessorElement element = currentElement.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     return null;
   }
 
-  bool _safeIsOrInheritsProxy(ClassElement classElt,
-      HashSet<ClassElement> visitedClassElts) {
+  bool _safeIsOrInheritsProxy(
+      ClassElement classElt, HashSet<ClassElement> visitedClassElts) {
     if (visitedClassElts.contains(classElt)) {
       return false;
     }
     visitedClassElts.add(classElt);
     if (classElt.isProxy) {
       return true;
     } else if (classElt.supertype != null &&
         _safeIsOrInheritsProxy(classElt.supertype.element, visitedClassElts)) {
       return true;
     }
@@ skipping 127 matching lines @@
    * @param className the name of the class to be returned
    * @return the class with the given name that is defined in this compilation unit
    */
   ClassElement getType(String className);
 }
 
 /**
  * Instances of the class `CompilationUnitElementImpl` implement a
  * [CompilationUnitElement].
  */
-class CompilationUnitElementImpl extends UriReferencedElementImpl implements
-    CompilationUnitElement {
+class CompilationUnitElementImpl extends UriReferencedElementImpl
+    implements CompilationUnitElement {
   /**
    * An empty list of compilation unit elements.
    */
-  static const List<CompilationUnitElement> EMPTY_ARRAY = const
-      <CompilationUnitElement>[
-      ];
+  static const List<CompilationUnitElement> EMPTY_ARRAY =
+      const <CompilationUnitElement>[];
 
   /**
    * The source that corresponds to this compilation unit.
    */
   Source source;
 
   /**
    * An array containing all of the top-level accessors (getters and setters) contained in this
    * compilation unit.
    */
@@ skipping 298 matching lines @@
   @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * The interface `ConstructorElement` defines the behavior of elements representing a
  * constructor or a factory method defined within a type.
  */
-abstract class ConstructorElement implements ClassMemberElement,
-    ExecutableElement {
+abstract class ConstructorElement
+    implements ClassMemberElement, ExecutableElement {
   /**
    * Return `true` if this constructor is a const constructor.
    *
    * @return `true` if this constructor is a const constructor
    */
   bool get isConst;
 
   /**
    * Return `true` if this constructor can be used as a default constructor - unnamed and has
    * no required parameters.
@@ skipping 39 matching lines @@
    * constructor has not yet been resolved.
    *
    * @return the constructor to which this constructor is redirecting
    */
   ConstructorElement get redirectedConstructor;
 }
 
 /**
  * Instances of the class `ConstructorElementImpl` implement a `ConstructorElement`.
  */
-class ConstructorElementImpl extends ExecutableElementImpl implements
-    ConstructorElement {
+class ConstructorElementImpl extends ExecutableElementImpl
+    implements ConstructorElement {
   /**
    * An empty list of constructor elements.
    */
-  static const List<ConstructorElement> EMPTY_ARRAY = const
-      <ConstructorElement>[
-      ];
+  static const List<ConstructorElement> EMPTY_ARRAY =
+      const <ConstructorElement>[];
 
   /**
    * The constructor to which this constructor is redirecting.
    */
   ConstructorElement redirectedConstructor;
 
   /**
    * The initializers for this constructor (used for evaluating constant instance creation
    * expressions).
    */
@@ skipping 188 matching lines @@
    * If the given constructor's type is different when any type parameters from the defining type's
    * declaration are replaced with the actual type arguments from the defining type, create a
    * constructor member representing the given constructor. Return the member that was created, or
    * the base constructor if no member was created.
    *
    * @param baseConstructor the base constructor for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the constructor element that will return the correctly substituted types
    */
-  static ConstructorElement from(ConstructorElement baseConstructor,
-      InterfaceType definingType) {
+  static ConstructorElement from(
+      ConstructorElement baseConstructor, InterfaceType definingType) {
     if (baseConstructor == null || definingType.typeArguments.length == 0) {
       return baseConstructor;
     }
     FunctionType baseType = baseConstructor.type;
     if (baseType == null) {
       // TODO(brianwilkerson) We need to understand when this can happen.
       return baseConstructor;
     }
     List<DartType> argumentTypes = definingType.typeArguments;
     List<DartType> parameterTypes = definingType.element.type.typeArguments;
@@ skipping 131 matching lines @@
    * <i>y<sub>i</sub>, 1 <= i <= n</i> have been replaced with
    * <i>x<sub>i</sub></i>.
    * </blockquote>
    * Note that, contrary to the specification, this method will not create a
    * copy of this type if no substitutions were required, but will return this
    * type directly.
    *
    * Note too that the current implementation of this method is only guaranteed
    * to work when the argument types are type variables.
    */
-  DartType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes);
+  DartType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes);
 }
 
 /**
  * Instances of the class `DefaultFieldFormalParameterElementImpl` implement a
  * `FieldFormalParameterElementImpl` for parameters that have an initializer.
  */
-class DefaultFieldFormalParameterElementImpl extends
-    FieldFormalParameterElementImpl {
+class DefaultFieldFormalParameterElementImpl
+    extends FieldFormalParameterElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
@@ skipping 113 matching lines @@
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is S
     if (identical(this, type)) {
       return true;
     }
     // else
     return withDynamic;
   }
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) =>
-      true;
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 
   @override
   bool isSupertypeOf(DartType type) => true;
 
   @override
-  DartType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) {
+  DartType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
 }
 
@@ skipping 18 matching lines @@
 abstract class Element {
   /**
    * An Unicode right arrow.
    */
   static final String RIGHT_ARROW = " \u2192 ";
 
   /**
    * A comparator that can be used to sort elements by their name offset. Elements with a smaller
    * offset will be sorted to be before elements with a larger name offset.
    */
-  static final Comparator<Element> SORT_BY_OFFSET =
-      (Element firstElement, Element secondElement) =>
-          firstElement.nameOffset - secondElement.nameOffset;
+  static final Comparator<Element> SORT_BY_OFFSET = (Element firstElement,
+          Element secondElement) =>
+      firstElement.nameOffset - secondElement.nameOffset;
 
   /**
    * Return the analysis context in which this element is defined.
    *
    * @return the analysis context in which this element is defined
    */
   AnalysisContext get context;
 
   /**
    * Return the display name of this element, or `null` if this element does not have a name.
@@ skipping 236 matching lines @@
   bool get isProxy;
 }
 
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * An empty list of annotations.
    */
-  static const List<ElementAnnotationImpl> EMPTY_ARRAY = const
-      <ElementAnnotationImpl>[
-      ];
+  static const List<ElementAnnotationImpl> EMPTY_ARRAY =
+      const <ElementAnnotationImpl>[];
 
   /**
    * The name of the class used to mark an element as being deprecated.
    */
   static String _DEPRECATED_CLASS_NAME = "Deprecated";
 
   /**
    * The name of the top-level variable used to mark an element as being deprecated.
    */
   static String _DEPRECATED_VARIABLE_NAME = "deprecated";
@@ skipping 510 matching lines @@
   static const ElementKind FUNCTION_TYPE_ALIAS =
       const ElementKind('FUNCTION_TYPE_ALIAS', 22, "function type alias");
 
   static const ElementKind TYPE_PARAMETER =
       const ElementKind('TYPE_PARAMETER', 23, "type parameter");
 
   static const ElementKind UNIVERSE =
       const ElementKind('UNIVERSE', 24, "<universe>");
 
   static const List<ElementKind> values = const [
-      CLASS,
-      COMPILATION_UNIT,
-      CONSTRUCTOR,
-      DYNAMIC,
-      EMBEDDED_HTML_SCRIPT,
-      ERROR,
-      EXPORT,
-      EXTERNAL_HTML_SCRIPT,
-      FIELD,
-      FUNCTION,
-      GETTER,
-      HTML,
-      IMPORT,
-      LABEL,
-      LIBRARY,
-      LOCAL_VARIABLE,
-      METHOD,
-      NAME,
-      PARAMETER,
-      PREFIX,
-      SETTER,
-      TOP_LEVEL_VARIABLE,
-      FUNCTION_TYPE_ALIAS,
-      TYPE_PARAMETER,
-      UNIVERSE];
+    CLASS,
+    COMPILATION_UNIT,
+    CONSTRUCTOR,
+    DYNAMIC,
+    EMBEDDED_HTML_SCRIPT,
+    ERROR,
+    EXPORT,
+    EXTERNAL_HTML_SCRIPT,
+    FIELD,
+    FUNCTION,
+    GETTER,
+    HTML,
+    IMPORT,
+    LABEL,
+    LIBRARY,
+    LOCAL_VARIABLE,
+    METHOD,
+    NAME,
+    PARAMETER,
+    PREFIX,
+    SETTER,
+    TOP_LEVEL_VARIABLE,
+    FUNCTION_TYPE_ALIAS,
+    TYPE_PARAMETER,
+    UNIVERSE
+  ];
 
   /**
    * The name displayed in the UI for this kind of element.
    */
   final String displayName;
 
   /**
    * Initialize a newly created element kind to have the given display name.
    *
    * @param displayName the name displayed in the UI for this kind of element
@@ skipping 321 matching lines @@
    *
    * @return the library element (not `null`)
    */
   LibraryElement get scriptLibrary;
 }
 
 /**
  * Instances of the class `EmbeddedHtmlScriptElementImpl` implement an
  * [EmbeddedHtmlScriptElement].
  */
-class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl implements
-    EmbeddedHtmlScriptElement {
+class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl
+    implements EmbeddedHtmlScriptElement {
   /**
    * The library defined by the script tag's content.
    */
   LibraryElement _scriptLibrary;
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
@@ skipping 108 matching lines @@
    *
    * @return the type of function defined by this executable element
    */
   FunctionType get type;
 }
 
 /**
  * The abstract class `ExecutableElementImpl` implements the behavior common to
  * `ExecutableElement`s.
  */
-abstract class ExecutableElementImpl extends ElementImpl implements
-    ExecutableElement {
+abstract class ExecutableElementImpl extends ElementImpl
+    implements ExecutableElement {
   /**
    * An empty list of executable elements.
    */
   static const List<ExecutableElement> EMPTY_ARRAY = const <ExecutableElement>[
-      ];
+  ];
 
   /**
    * An array containing all of the functions defined within this executable element.
    */
   List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the labels defined within this executable element.
    */
   List<LabelElement> _labels = LabelElementImpl.EMPTY_ARRAY;
@@ skipping 314 matching lines @@
    * Return the library that is exported from this library by this export directive.
    *
    * @return the library that is exported from this library
    */
   LibraryElement get exportedLibrary;
 }
 
 /**
  * Instances of the class `ExportElementImpl` implement an [ExportElement].
  */
-class ExportElementImpl extends UriReferencedElementImpl implements
-    ExportElement {
+class ExportElementImpl extends UriReferencedElementImpl
+    implements ExportElement {
   /**
    * The library that is exported from this library by this export directive.
    */
   LibraryElement exportedLibrary;
 
   /**
    * The combinators that were specified as part of the export directive in the order in which they
    * were specified.
    */
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
@@ skipping 31 matching lines @@
    *
    * @return the source for the external Dart library
    */
   Source get scriptSource;
 }
 
 /**
  * Instances of the class `ExternalHtmlScriptElementImpl` implement an
  * [ExternalHtmlScriptElement].
  */
-class ExternalHtmlScriptElementImpl extends HtmlScriptElementImpl implements
-    ExternalHtmlScriptElement {
+class ExternalHtmlScriptElementImpl extends HtmlScriptElementImpl
+    implements ExternalHtmlScriptElement {
   /**
    * The source specified in the `source` attribute or `null` if unspecified.
    */
   Source scriptSource;
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node);
 
   @override
   ElementKind get kind => ElementKind.EXTERNAL_HTML_SCRIPT;
 
   @override
   accept(ElementVisitor visitor) =>
       visitor.visitExternalHtmlScriptElement(this);
 }
 
 /**
  * The interface `FieldElement` defines the behavior of elements representing a field defined
  * within a type.
  */
-abstract class FieldElement implements ClassMemberElement,
-    PropertyInducingElement {
+abstract class FieldElement
+    implements ClassMemberElement, PropertyInducingElement {
   /**
    * Return {@code true} if this element is an enum constant.
    *
    * @return {@code true} if this an enum constant
    */
   bool get isEnumConstant;
 }
 
 /**
  * Instances of the class `FieldElementImpl` implement a `FieldElement`.
  */
-class FieldElementImpl extends PropertyInducingElementImpl implements
-    FieldElement {
+class FieldElementImpl extends PropertyInducingElementImpl
+    implements FieldElement {
   /**
    * An empty list of field elements.
    */
   static const List<FieldElement> EMPTY_ARRAY = const <FieldElement>[];
 
   /**
    * Initialize a newly created synthetic field element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
@@ skipping 46 matching lines @@
    * @return the field element associated with this field formal parameter
    */
   FieldElement get field;
 }
 
 /**
  * Instances of the class `FieldFormalParameterElementImpl` extend
  * [ParameterElementImpl] to provide the additional information of the [FieldElement]
  * associated with the parameter.
  */
-class FieldFormalParameterElementImpl extends ParameterElementImpl implements
-    FieldFormalParameterElement {
+class FieldFormalParameterElementImpl extends ParameterElementImpl
+    implements FieldFormalParameterElement {
   /**
    * The field associated with this field formal parameter.
    */
   FieldElement field;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   FieldFormalParameterElementImpl(Identifier name) : super.forNode(name);
 
   @override
   bool get isInitializingFormal => true;
 
   @override
   accept(ElementVisitor visitor) =>
       visitor.visitFieldFormalParameterElement(this);
 }
 
 /**
  * Instances of the class `FieldFormalParameterMember` represent a parameter element defined
  * in a parameterized type where the values of the type parameters are known.
  */
-class FieldFormalParameterMember extends ParameterMember implements
-    FieldFormalParameterElement {
+class FieldFormalParameterMember extends ParameterMember
+    implements FieldFormalParameterElement {
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  FieldFormalParameterMember(FieldFormalParameterElement baseElement,
-      ParameterizedType definingType)
+  FieldFormalParameterMember(
+      FieldFormalParameterElement baseElement, ParameterizedType definingType)
       : super(baseElement, definingType);
 
   @override
   FieldElement get field {
     FieldElement field = (baseElement as FieldFormalParameterElement).field;
     if (field is FieldElement) {
       return FieldMember.from(field, definingType);
     }
     return field;
   }
@@ skipping 72 matching lines @@
 
   /**
    * Determine whether the given field's type is changed when type parameters from the defining
    * type's declaration are replaced with the actual type arguments from the defining type.
    *
    * @param baseField the base field
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return true if the type is changed by type substitution.
    */
-  static bool _isChangedByTypeSubstitution(FieldElement baseField,
-      InterfaceType definingType) {
+  static bool _isChangedByTypeSubstitution(
+      FieldElement baseField, InterfaceType definingType) {
     List<DartType> argumentTypes = definingType.typeArguments;
     if (baseField != null && argumentTypes.length != 0) {
       DartType baseType = baseField.type;
       List<DartType> parameterTypes = definingType.element.type.typeArguments;
       if (baseType != null) {
         DartType substitutedType =
             baseType.substitute2(argumentTypes, parameterTypes);
         if (baseType != substitutedType) {
           return true;
         }
@@ skipping 43 matching lines @@
    *
    * @return the resolved [FunctionDeclaration], not `null`.
    */
   @override
   FunctionDeclaration get node;
 }
 
 /**
  * Instances of the class `FunctionElementImpl` implement a `FunctionElement`.
  */
-class FunctionElementImpl extends ExecutableElementImpl implements
-    FunctionElement {
+class FunctionElementImpl extends ExecutableElementImpl
+    implements FunctionElement {
   /**
    * An empty list of function elements.
    */
   static const List<FunctionElement> EMPTY_ARRAY = const <FunctionElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
@@ skipping 188 matching lines @@
    * `call()`, and the type of `call()` is the function type <i>F</i>, then <i>I</i> is
    * considered to be a subtype of <i>F</i>.
    *
    * @param type the type being compared with this type
    * @return `true` if this type is a subtype of the given type
    */
   @override
   bool isSubtypeOf(DartType type);
 
   @override
-  FunctionType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes);
+  FunctionType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes);
 
   /**
    * Return the type resulting from substituting the given arguments for this type's parameters.
    * This is fully equivalent to `substitute(argumentTypes, getTypeArguments())`.
    *
    * @param argumentTypes the actual type arguments being substituted for the type parameters
    * @return the result of performing the substitution
    */
   FunctionType substitute3(List<DartType> argumentTypes);
 }
@@ skipping 49 matching lines @@
    *
    * @return the type parameters defined for this type
    */
   List<TypeParameterElement> get typeParameters;
 }
 
 /**
  * Instances of the class `FunctionTypeAliasElementImpl` implement a
  * `FunctionTypeAliasElement`.
  */
-class FunctionTypeAliasElementImpl extends ElementImpl implements
-    FunctionTypeAliasElement {
+class FunctionTypeAliasElementImpl extends ElementImpl
+    implements FunctionTypeAliasElement {
   /**
    * An empty array of type alias elements.
    */
   static List<FunctionTypeAliasElement> EMPTY_ARRAY =
       new List<FunctionTypeAliasElement>(0);
 
   /**
    * An array containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
@@ skipping 375 matching lines @@
       // null and we need to understand why it is and fix it.
       return DynamicTypeImpl.instance;
     }
     // If there are no arguments to substitute, or if the arguments size doesn't
     // match the parameter size, return the base return type.
     if (typeArguments.length == 0 ||
         typeArguments.length != typeParameters.length) {
       return baseReturnType;
     }
     return baseReturnType.substitute2(
-        typeArguments,
-        TypeParameterTypeImpl.getTypes(typeParameters));
+        typeArguments, TypeParameterTypeImpl.getTypes(typeParameters));
   }
 
   @override
   List<TypeParameterElement> get typeParameters {
     Element element = this.element;
     if (element is FunctionTypeAliasElement) {
       return element.typeParameters;
     }
     ClassElement definingClass =
         element.getAncestor((element) => element is ClassElement);
@@ skipping 80 matching lines @@
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     // If the visitedTypePairs already has the pair (this, type),
     // use the elements to determine equality
     ElementPair elementPair = new ElementPair(element, otherType.element);
     if (!visitedElementPairs.add(elementPair)) {
       return elementPair.firstElt == elementPair.secondElt;
     }
     // Compute the result
-    bool result =
-        TypeImpl.equalArrays(
-            normalParameterTypes,
-            otherType.normalParameterTypes,
-            visitedElementPairs) &&
-        TypeImpl.equalArrays(
-            optionalParameterTypes,
-            otherType.optionalParameterTypes,
-            visitedElementPairs) &&
-        _equals(
-            namedParameterTypes,
-            otherType.namedParameterTypes,
+    bool result = TypeImpl.equalArrays(normalParameterTypes,
+            otherType.normalParameterTypes, visitedElementPairs) &&
+        TypeImpl.equalArrays(optionalParameterTypes,
+            otherType.optionalParameterTypes, visitedElementPairs) &&
+        _equals(namedParameterTypes, otherType.namedParameterTypes,
             visitedElementPairs) &&
         (returnType as TypeImpl).internalEquals(
-            otherType.returnType,
-            visitedElementPairs);
+            otherType.returnType, visitedElementPairs);
     // Remove the pair from our visited pairs list
     visitedElementPairs.remove(elementPair);
     // Return the result
     return result;
   }
 
   @override
   int internalHashCode(List<DartType> visitedTypes) {
     if (element == null) {
       return 0;
     } else if (visitedTypes.contains(this)) {
       return 3;
     }
     visitedTypes.add(this);
     // Reference the arrays of parameters
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     Iterable<DartType> namedParameterTypes = this.namedParameterTypes.values;
     // Generate the hashCode
     int code = (returnType as TypeImpl).internalHashCode(visitedTypes);
     for (int i = 0; i < normalParameterTypes.length; i++) {
       code = (code << 1) +
           (normalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
     }
     for (int i = 0; i < optionalParameterTypes.length; i++) {
       code = (code << 1) +
-          (optionalParameterTypes[i] as TypeImpl).internalHashCode(visitedTypes);
+          (optionalParameterTypes[i] as TypeImpl)
+              .internalHashCode(visitedTypes);
     }
     for (DartType type in namedParameterTypes) {
       code = (code << 1) + (type as TypeImpl).internalHashCode(visitedTypes);
     }
     return code;
   }
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
     } else if (identical(this, type) ||
         type.isDynamic ||
         type.isDartCoreFunction ||
         type.isObject) {
       return true;
     } else if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsLessSpecificThan(
-          this,
-          withDynamic,
-          visitedTypePairs);
+          this, withDynamic, visitedTypePairs);
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
     }
     FunctionType t = this;
     FunctionType s = type as FunctionType;
     List<DartType> tTypes = t.normalParameterTypes;
     List<DartType> tOpTypes = t.optionalParameterTypes;
     List<DartType> sTypes = s.normalParameterTypes;
     List<DartType> sOpTypes = s.optionalParameterTypes;
     // If one function has positional and the other has named parameters,
     // return false.
     if ((sOpTypes.length > 0 && t.namedParameterTypes.length > 0) ||
         (tOpTypes.length > 0 && s.namedParameterTypes.length > 0)) {
       return false;
     }
     // named parameters case
     if (t.namedParameterTypes.length > 0) {
       // check that the number of required parameters are equal, and check that
       // every t_i is more specific than every s_i
       if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
         return false;
       } else if (t.normalParameterTypes.length > 0) {
         for (int i = 0; i < tTypes.length; i++) {
           if (!(tTypes[i] as TypeImpl).isMoreSpecificThan2(
-              sTypes[i],
-              withDynamic,
-              visitedTypePairs)) {
+              sTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       }
       Map<String, DartType> namedTypesT = t.namedParameterTypes;
       Map<String, DartType> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more
       // named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching
       // parameter name and that the corresponding type is more specific then
       // the type in S.
       for (String keyS in namedTypesS.keys) {
         DartType typeT = namedTypesT[keyS];
         if (typeT == null) {
           return false;
         }
         if (!(typeT as TypeImpl).isMoreSpecificThan2(
-            namedTypesS[keyS],
-            withDynamic,
-            visitedTypePairs)) {
+            namedTypesS[keyS], withDynamic, visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal
       // to the number of parameters in s and that the number of required
       // parameters in s is greater than or equal to the number of required
       // parameters in t.
       if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
         return false;
       }
       if (tOpTypes.length == 0 && sOpTypes.length == 0) {
         // No positional arguments, don't copy contents to new array
         for (int i = 0; i < sTypes.length; i++) {
           if (!(tTypes[i] as TypeImpl).isMoreSpecificThan2(
-              sTypes[i],
-              withDynamic,
-              visitedTypePairs)) {
+              sTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       } else {
         // Else, we do have positional parameters, copy required and positional
         // parameter types into arrays to do the compare (for loop below).
         List<DartType> tAllTypes = new List<DartType>(sArgLength);
         for (int i = 0; i < tTypes.length; i++) {
           tAllTypes[i] = tTypes[i];
         }
-        for (int i = tTypes.length,
-            j = 0; i < sArgLength; i++, j++) {
+        for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
           tAllTypes[i] = tOpTypes[j];
         }
         List<DartType> sAllTypes = new List<DartType>(sArgLength);
         for (int i = 0; i < sTypes.length; i++) {
           sAllTypes[i] = sTypes[i];
         }
-        for (int i = sTypes.length,
-            j = 0; i < sArgLength; i++, j++) {
+        for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
           sAllTypes[i] = sOpTypes[j];
         }
         for (int i = 0; i < sAllTypes.length; i++) {
           if (!(tAllTypes[i] as TypeImpl).isMoreSpecificThan2(
-              sAllTypes[i],
-              withDynamic,
-              visitedTypePairs)) {
+              sAllTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       }
     }
     DartType tRetType = t.returnType;
     DartType sRetType = s.returnType;
     return sRetType.isVoid ||
         (tRetType as TypeImpl).isMoreSpecificThan2(
-            sRetType,
-            withDynamic,
-            visitedTypePairs);
+            sRetType, withDynamic, visitedTypePairs);
   }
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
     } else if (identical(this, type) ||
         type.isDynamic ||
         type.isDartCoreFunction ||
         type.isObject) {
       return true;
     } else if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(
-          this,
-          visitedTypePairs);
+          this, visitedTypePairs);
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
     }
     FunctionType t = this;
     FunctionType s = type as FunctionType;
     List<DartType> tTypes = t.normalParameterTypes;
     List<DartType> tOpTypes = t.optionalParameterTypes;
     List<DartType> sTypes = s.normalParameterTypes;
     List<DartType> sOpTypes = s.optionalParameterTypes;
     // If one function has positional and the other has named parameters,
     // return false.
     if ((sOpTypes.length > 0 && t.namedParameterTypes.length > 0) ||
         (tOpTypes.length > 0 && s.namedParameterTypes.length > 0)) {
       return false;
     }
     // named parameters case
     if (t.namedParameterTypes.length > 0) {
       // check that the number of required parameters are equal,
       // and check that every t_i is assignable to every s_i
       if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
         return false;
       } else if (t.normalParameterTypes.length > 0) {
         for (int i = 0; i < tTypes.length; i++) {
           if (!(tTypes[i] as TypeImpl).isAssignableTo2(
-              sTypes[i],
-              visitedTypePairs)) {
+              sTypes[i], visitedTypePairs)) {
             return false;
           }
         }
       }
       Map<String, DartType> namedTypesT = t.namedParameterTypes;
       Map<String, DartType> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more
       // named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching
       // parameter name and that the corresponding type is assignable to the
       // type in S.
       for (String keyS in namedTypesS.keys) {
         DartType typeT = namedTypesT[keyS];
         if (typeT == null) {
           return false;
         }
         if (!(typeT as TypeImpl).isAssignableTo2(
-            namedTypesS[keyS],
-            visitedTypePairs)) {
+            namedTypesS[keyS], visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal
       // to the number of parameters in s and that the number of required
       // parameters in s is greater than or equal to the number of required
       // parameters in t.
       if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
         return false;
       }
       if (tOpTypes.length == 0 && sOpTypes.length == 0) {
         // No positional arguments, don't copy contents to new array
         for (int i = 0; i < sTypes.length; i++) {
           if (!(tTypes[i] as TypeImpl).isAssignableTo2(
-              sTypes[i],
-              visitedTypePairs)) {
+              sTypes[i], visitedTypePairs)) {
             return false;
           }
         }
       } else {
         // Else, we do have positional parameters, copy required and positional
         // parameter types into arrays to do the compare (for loop below).
         List<DartType> tAllTypes = new List<DartType>(sArgLength);
         for (int i = 0; i < tTypes.length; i++) {
           tAllTypes[i] = tTypes[i];
         }
-        for (int i = tTypes.length,
-            j = 0; i < sArgLength; i++, j++) {
+        for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
           tAllTypes[i] = tOpTypes[j];
         }
         List<DartType> sAllTypes = new List<DartType>(sArgLength);
         for (int i = 0; i < sTypes.length; i++) {
           sAllTypes[i] = sTypes[i];
         }
-        for (int i = sTypes.length,
-            j = 0; i < sArgLength; i++, j++) {
+        for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
           sAllTypes[i] = sOpTypes[j];
         }
         for (int i = 0; i < sAllTypes.length; i++) {
           if (!(tAllTypes[i] as TypeImpl).isAssignableTo2(
-              sAllTypes[i],
-              visitedTypePairs)) {
+              sAllTypes[i], visitedTypePairs)) {
             return false;
           }
         }
       }
     }
     DartType tRetType = t.returnType;
     DartType sRetType = s.returnType;
     return sRetType.isVoid ||
         (tRetType as TypeImpl).isAssignableTo2(sRetType, visitedTypePairs);
   }
 
   /**
    * Return `true` if this type is assignable to the given type. A function type <i>T</i> may
    * be assigned to a function type <i>S</i>, written <i>T</i> &hArr; <i>S</i>, iff <i>T</i> <:
    * <i>S</i> (Function Types section of spec). Note that this is more restrictive than the
    * "may be assigned to" rule for interface types.
    *
    *
    * @param type the type being compared with this type
    * @return `true` if this type is assignable to the given type
    */
   @override
   bool isAssignableTo(DartType type) =>
       isSubtypeOf2(type, new HashSet<TypeImpl_TypePair>());
 
   @override
-  FunctionTypeImpl substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) {
+  FunctionTypeImpl substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) {
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException(
           "argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0) {
       return this;
     }
     Element element = this.element;
-    FunctionTypeImpl newType = (element is ExecutableElement) ?
-        new FunctionTypeImpl.con1(element) :
-        new FunctionTypeImpl.con2(element as FunctionTypeAliasElement);
+    FunctionTypeImpl newType = (element is ExecutableElement)
+        ? new FunctionTypeImpl.con1(element)
+        : new FunctionTypeImpl.con2(element as FunctionTypeAliasElement);
     newType.typeArguments =
         TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
     return newType;
   }
 
   @override
   FunctionTypeImpl substitute3(List<DartType> argumentTypes) =>
       substitute2(argumentTypes, typeArguments);
 
   /**
    * Return `true` if all of the name/type pairs in the first map are equal to the
    * corresponding name/type pairs in the second map. The maps are expected to iterate over their
    * entries in the same order in which those entries were added to the map.
    *
    * @param firstTypes the first map of name/type pairs being compared
    * @param secondTypes the second map of name/type pairs being compared
    * @param visitedElementPairs a set of visited element pairs
    * @return `true` if all of the name/type pairs in the first map are equal to the
    *         corresponding name/type pairs in the second map
    */
-  static bool _equals(Map<String, DartType> firstTypes, Map<String,
-      DartType> secondTypes, Set<ElementPair> visitedElementPairs) {
+  static bool _equals(Map<String, DartType> firstTypes,
+      Map<String, DartType> secondTypes, Set<ElementPair> visitedElementPairs) {
     if (secondTypes.length != firstTypes.length) {
       return false;
     }
     Iterator<String> firstKeys = firstTypes.keys.iterator;
     Iterator<String> secondKeys = secondTypes.keys.iterator;
     while (firstKeys.moveNext() && secondKeys.moveNext()) {
       String firstKey = firstKeys.current;
       String secondKey = secondKeys.current;
       TypeImpl firstType = firstTypes[firstKey];
       TypeImpl secondType = secondTypes[secondKey];
@@ skipping 308 matching lines @@
     safelyVisitChildren(_scripts, visitor);
   }
 }
 
 /**
  * The interface `HtmlScriptElement` defines the behavior of elements representing a script
  * tag in an HTML file.
  *
  * See [EmbeddedHtmlScriptElement], and [ExternalHtmlScriptElement],
  */
-abstract class HtmlScriptElement implements Element {
-}
+abstract class HtmlScriptElement implements Element {}
 
 /**
  * Instances of the class `HtmlScriptElementImpl` implement an [HtmlScriptElement].
  */
-abstract class HtmlScriptElementImpl extends ElementImpl implements
-    HtmlScriptElement {
+abstract class HtmlScriptElementImpl extends ElementImpl
+    implements HtmlScriptElement {
   /**
    * An empty list of HTML script elements.
    */
   static const List<HtmlScriptElement> EMPTY_ARRAY = const <HtmlScriptElement>[
-      ];
+  ];
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   HtmlScriptElementImpl(XmlTagNode node)
       : super(node.tag, node.tagToken.offset);
 }
 
@@ skipping 43 matching lines @@
    * an offset.
    *
    * @return the offset of the prefix of this import
    */
   int get prefixOffset;
 }
 
 /**
  * Instances of the class `ImportElementImpl` implement an [ImportElement].
  */
-class ImportElementImpl extends UriReferencedElementImpl implements
-    ImportElement {
+class ImportElementImpl extends UriReferencedElementImpl
+    implements ImportElement {
   /**
    * The offset of the prefix of this import in the file that contains the this import directive, or
    * `-1` if this import is synthetic.
    */
   int prefixOffset = 0;
 
   /**
    * The library that is imported into this library by this import directive.
    */
   LibraryElement importedLibrary;
@@ skipping 208 matching lines @@
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.11.1: <blockquote>If <i>e</i> is of the form <b>new</b> <i>T.id()</i> then let <i>q<i> be
    * the constructor <i>T.id</i>, otherwise let <i>q<i> be the constructor <i>T<i>. Otherwise, if
    * <i>q</i> is not defined or not accessible, a NoSuchMethodException is thrown. </blockquote>
    *
    * @param constructorName the name of the constructor being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given constructor in this class with respect to the given
    *         library
    */
-  ConstructorElement lookUpConstructor(String constructorName,
-      LibraryElement library);
+  ConstructorElement lookUpConstructor(
+      String constructorName, LibraryElement library);
 
   /**
    * Return the element representing the getter that results from looking up the given getter in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpGetter(String getterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpGetter(
+      String getterName, LibraryElement library);
 
   /**
    * Return the element representing the getter that results from looking up the given getter in the
    * superclass of this class with respect to the given library, or `null` if the look up
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.15.1: <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpGetterInSuperclass(String getterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpGetterInSuperclass(
+      String getterName, LibraryElement library);
 
   /**
    * Return the element representing the method that results from looking up the given method in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect to library
    * <i>L</i> is:
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
@@ skipping 17 matching lines @@
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param methodName the name of the method being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given method in this class with respect to the given
    *         library
    */
-  MethodElement lookUpMethodInSuperclass(String methodName,
-      LibraryElement library);
+  MethodElement lookUpMethodInSuperclass(
+      String methodName, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the given setter in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.16:
    * <blockquote> The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param setterName the name of the setter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given setter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpSetter(String setterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpSetter(
+      String setterName, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the given setter in the
    * superclass of this class with respect to the given library, or `null` if the look up
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.16: <blockquote> The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
    * </blockquote>
    *
    * @param setterName the name of the setter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given setter in this class with respect to the given
    *         library
    */
-  PropertyAccessorElement lookUpSetterInSuperclass(String setterName,
-      LibraryElement library);
+  PropertyAccessorElement lookUpSetterInSuperclass(
+      String setterName, LibraryElement library);
 
   @override
-  InterfaceType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes);
+  InterfaceType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes);
 
   /**
    * Return the type resulting from substituting the given arguments for this
    * type's parameters. This is fully equivalent to `substitute2(argumentTypes,
    * getTypeArguments())`.
    */
   InterfaceType substitute4(List<DartType> argumentTypes);
 
   /**
    * Returns a "smart" version of the "least upper bound" of the given types.
    *
    * If these types have the same element and differ only in terms of the type
    * arguments, attempts to find a compatible set of type arguments.
    *
    * Otherwise, calls [DartType.getLeastUpperBound].
    */
-  static InterfaceType getSmartLeastUpperBound(InterfaceType first,
-      InterfaceType second) {
+  static InterfaceType getSmartLeastUpperBound(
+      InterfaceType first, InterfaceType second) {
     if (first.element == second.element) {
       return _leastUpperBound(first, second);
     }
     return first.getLeastUpperBound(second);
   }
 
   /**
    * Return the "least upper bound" of the given types under the assumption that
    * the types have the same element and differ only in terms of the type
    * arguments.
    *
    * The resulting type is composed by comparing the corresponding type
    * arguments, keeping those that are the same, and using 'dynamic' for those
    * that are different.
    */
-  static InterfaceType _leastUpperBound(InterfaceType firstType,
-      InterfaceType secondType) {
+  static InterfaceType _leastUpperBound(
+      InterfaceType firstType, InterfaceType secondType) {
     ClassElement firstElement = firstType.element;
     ClassElement secondElement = secondType.element;
     if (firstElement != secondElement) {
-      throw new IllegalArgumentException(
-          'The same elements expected, but '
-              '$firstElement and $secondElement are given.');
+      throw new IllegalArgumentException('The same elements expected, but '
+          '$firstElement and $secondElement are given.');
     }
     if (firstType == secondType) {
       return firstType;
     }
     List<DartType> firstArguments = firstType.typeArguments;
     List<DartType> secondArguments = secondType.typeArguments;
     int argumentCount = firstArguments.length;
     if (argumentCount == 0) {
       return firstType;
     }
@@ skipping 189 matching lines @@
         if (i > 0) {
           buffer.write(", ");
         }
         (typeArguments[i] as TypeImpl).appendTo(buffer, visitedTypes);
       }
       buffer.write(">");
     }
   }
 
   @override
-  PropertyAccessorElement getGetter(String getterName) =>
-      PropertyAccessorMember.from(
-          (element as ClassElementImpl).getGetter(getterName),
-          this);
+  PropertyAccessorElement getGetter(String getterName) => PropertyAccessorMember
+      .from((element as ClassElementImpl).getGetter(getterName), this);
 
   @override
   DartType getLeastUpperBound(DartType type) {
     // quick check for self
     if (identical(type, this)) {
       return this;
     }
     // dynamic
     DartType dynamicType = DynamicTypeImpl.instance;
     if (identical(this, dynamicType) || identical(type, dynamicType)) {
@@ skipping 19 matching lines @@
     List<int> depths = new List<int>.filled(s.length, 0);
     int maxDepth = 0;
     for (int n = 0; n < s.length; n++) {
       depths[n] = computeLongestInheritancePathToObject(s[n]);
       if (depths[n] > maxDepth) {
         maxDepth = depths[n];
       }
     }
     // ensure that the currently computed maxDepth is unique,
     // otherwise, decrement and test for uniqueness again
-    for ( ; maxDepth >= 0; maxDepth--) {
+    for (; maxDepth >= 0; maxDepth--) {
       int indexOfLeastUpperBound = -1;
       int numberOfTypesAtMaxDepth = 0;
       for (int m = 0; m < depths.length; m++) {
         if (depths[m] == maxDepth) {
           numberOfTypesAtMaxDepth++;
           indexOfLeastUpperBound = m;
         }
       }
       if (numberOfTypesAtMaxDepth == 1) {
         return s[indexOfLeastUpperBound];
       }
     }
     // illegal state, log and return null- Object at maxDepth == 0 should always
     // return itself as the least upper bound.
     // TODO (jwren) log the error state
     return null;
   }
 
   @override
-  MethodElement getMethod(String methodName) =>
-      MethodMember.from((element as ClassElementImpl).getMethod(methodName), this);
+  MethodElement getMethod(String methodName) => MethodMember.from(
+      (element as ClassElementImpl).getMethod(methodName), this);
 
   @override
-  PropertyAccessorElement getSetter(String setterName) =>
-      PropertyAccessorMember.from(
-          (element as ClassElementImpl).getSetter(setterName),
-          this);
+  PropertyAccessorElement getSetter(String setterName) => PropertyAccessorMember
+      .from((element as ClassElementImpl).getSetter(setterName), this);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
     if (object is! InterfaceTypeImpl) {
       return false;
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return (element == otherType.element) &&
         TypeImpl.equalArrays(
-            typeArguments,
-            otherType.typeArguments,
-            visitedElementPairs);
+            typeArguments, otherType.typeArguments, visitedElementPairs);
   }
 
   @override
   int internalHashCode(List<DartType> visitedTypes) => hashCode;
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // S is dynamic.
     // The test to determine whether S is dynamic is done here because dynamic
     // is not an instance of InterfaceType.
     //
     if (type.isDynamic) {
       return true;
     } else if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsLessSpecificThan(
-          this,
-          withDynamic,
-          visitedTypePairs);
+          this, withDynamic, visitedTypePairs);
     } else if (type is! InterfaceType) {
       return false;
     }
-    return _isMoreSpecificThan(
-        type as InterfaceType,
-        new HashSet<ClassElement>(),
-        withDynamic,
-        visitedTypePairs);
+    return _isMoreSpecificThan(type as InterfaceType,
+        new HashSet<ClassElement>(), withDynamic, visitedTypePairs);
   }
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // T is a subtype of S, written T <: S, iff [bottom/dynamic]T << S
     //
     if (type.isDynamic) {
       return true;
     } else if (type is TypeParameterType) {
       return false;
     } else if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(
-          this,
-          visitedTypePairs);
+          this, visitedTypePairs);
     } else if (type is FunctionType) {
       // This implementation assumes transitivity
       // for function type subtyping on the RHS, but a literal reading
       // of the spec does not specify this. More precisely:
       // if T <: F1 and F1 <: F2 and F1 and F2 are function types,
       // then we assume T <: F2.
       //
       // From the Function Types section of the spec:
       //
       //   If a type I includes an instance method named call(), and the type of
@@ skipping 49 matching lines @@
         // (tools/test.py --mode release --compiler dartanalyzer --runtime none)
         return callType.isSubtypeOf(type);
       }
       return false;
     } else if (type is! InterfaceType) {
       return false;
     } else if (this == type) {
       return true;
     }
     return _isSubtypeOf(
-        type as InterfaceType,
-        new HashSet<ClassElement>(),
-        visitedTypePairs);
+        type as InterfaceType, new HashSet<ClassElement>(), visitedTypePairs);
   }
 
   @override
   bool isDirectSupertypeOf(InterfaceType type) {
     InterfaceType i = this;
     InterfaceType j = type;
     ClassElement jElement = j.element;
     InterfaceType supertype = jElement.supertype;
     //
     // If J has no direct supertype then it is Object, and Object has no direct
@@ skipping 31 matching lines @@
     }
     //
     // J is a mixin application of the mixin of I.
     //
     // TODO(brianwilkerson) Determine whether this needs to be implemented or
     // whether it is covered by the case above.
     return false;
   }
 
   @override
-  ConstructorElement lookUpConstructor(String constructorName,
-      LibraryElement library) {
+  ConstructorElement lookUpConstructor(
+      String constructorName, LibraryElement library) {
     // prepare base ConstructorElement
     ConstructorElement constructorElement;
     if (constructorName == null) {
       constructorElement = element.unnamedConstructor;
     } else {
       constructorElement = element.getNamedConstructor(constructorName);
     }
     // not found or not accessible
     if (constructorElement == null ||
         !constructorElement.isAccessibleIn(library)) {
       return null;
     }
     // return member
     return ConstructorMember.from(constructorElement, this);
   }
 
   @override
-  PropertyAccessorElement lookUpGetter(String getterName,
-      LibraryElement library) {
+  PropertyAccessorElement lookUpGetter(
+      String getterName, LibraryElement library) {
     PropertyAccessorElement element = getGetter(getterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     return lookUpGetterInSuperclass(getterName, library);
   }
 
   @override
-  PropertyAccessorElement lookUpGetterInSuperclass(String getterName,
-      LibraryElement library) {
+  PropertyAccessorElement lookUpGetterInSuperclass(
+      String getterName, LibraryElement library) {
     for (InterfaceType mixin in mixins.reversed) {
       PropertyAccessorElement element = mixin.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement =
         supertype == null ? null : supertype.element;
@@ skipping 18 matching lines @@
   @override
   MethodElement lookUpMethod(String methodName, LibraryElement library) {
     MethodElement element = getMethod(methodName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     return lookUpMethodInSuperclass(methodName, library);
   }
 
   @override
-  MethodElement lookUpMethodInSuperclass(String methodName,
-      LibraryElement library) {
+  MethodElement lookUpMethodInSuperclass(
+      String methodName, LibraryElement library) {
     for (InterfaceType mixin in mixins.reversed) {
       MethodElement element = mixin.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement =
         supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
       visitedClasses.add(supertypeElement);
       MethodElement element = supertype.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins.reversed) {
         element = mixin.getMethod(methodName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
       supertype = supertype.superclass;
       supertypeElement = supertype == null ? null : supertype.element;
     }
     return null;
   }
 
   @override
-  PropertyAccessorElement lookUpSetter(String setterName,
-      LibraryElement library) {
+  PropertyAccessorElement lookUpSetter(
+      String setterName, LibraryElement library) {
     PropertyAccessorElement element = getSetter(setterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     return lookUpSetterInSuperclass(setterName, library);
   }
 
   @override
-  PropertyAccessorElement lookUpSetterInSuperclass(String setterName,
-      LibraryElement library) {
+  PropertyAccessorElement lookUpSetterInSuperclass(
+      String setterName, LibraryElement library) {
     for (InterfaceType mixin in mixins.reversed) {
       PropertyAccessorElement element = mixin.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement =
         supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
       visitedClasses.add(supertypeElement);
       PropertyAccessorElement element = supertype.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins.reversed) {
         element = mixin.getSetter(setterName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
       supertype = supertype.superclass;
       supertypeElement = supertype == null ? null : supertype.element;
     }
     return null;
   }
 
   @override
-  InterfaceTypeImpl substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) {
+  InterfaceTypeImpl substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) {
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException(
           "argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0 || typeArguments.length == 0) {
       return this;
     }
     List<DartType> newTypeArguments =
         TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
     if (JavaArrays.equals(newTypeArguments, typeArguments)) {
@@ skipping 35 matching lines @@
     ClassElement tElement = this.element;
     ClassElement sElement = s.element;
     if (tElement == sElement) {
       List<DartType> tArguments = typeArguments;
       List<DartType> sArguments = s.typeArguments;
       if (tArguments.length != sArguments.length) {
         return false;
       }
       for (int i = 0; i < tArguments.length; i++) {
         if (!(tArguments[i] as TypeImpl).isMoreSpecificThan2(
-            sArguments[i],
-            withDynamic,
-            visitedTypePairs)) {
+            sArguments[i], withDynamic, visitedTypePairs)) {
           return false;
         }
       }
       return true;
     }
     //
     // Transitivity: T << U and U << S.
     //
     // First check for infinite loops
     ClassElement element = this.element;
     if (element == null || visitedClasses.contains(element)) {
       return false;
     }
     visitedClasses.add(element);
     // Iterate over all of the types U that are more specific than T because
     // they are direct supertypes of T and return true if any of them are more
     // specific than S.
     InterfaceType supertype = superclass;
     if (supertype != null &&
         (supertype as InterfaceTypeImpl)._isMoreSpecificThan(
-            s,
-            visitedClasses,
-            withDynamic,
-            visitedTypePairs)) {
+            s, visitedClasses, withDynamic, visitedTypePairs)) {
       return true;
     }
     for (InterfaceType interfaceType in interfaces) {
       if ((interfaceType as InterfaceTypeImpl)._isMoreSpecificThan(
-          s,
-          visitedClasses,
-          withDynamic,
-          visitedTypePairs)) {
+          s, visitedClasses, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
     for (InterfaceType mixinType in mixins) {
       if ((mixinType as InterfaceTypeImpl)._isMoreSpecificThan(
-          s,
-          visitedClasses,
-          withDynamic,
-          visitedTypePairs)) {
+          s, visitedClasses, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
   bool _isSubtypeOf(InterfaceType type, HashSet<ClassElement> visitedClasses,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     InterfaceType typeT = this;
     InterfaceType typeS = type;
@@ skipping 11 matching lines @@
       List<DartType> typeSArgs = typeS.typeArguments;
       if (typeTArgs.length != typeSArgs.length) {
         // This case covers the case where two objects are being compared that
         // have a different number of parameterized types.
         return false;
       }
       for (int i = 0; i < typeTArgs.length; i++) {
         // Recursively call isSubtypeOf the type arguments and return false if
         // the T argument is not a subtype of the S argument.
         if (!(typeTArgs[i] as TypeImpl).isSubtypeOf2(
-            typeSArgs[i],
-            visitedTypePairs)) {
+            typeSArgs[i], visitedTypePairs)) {
           return false;
         }
       }
       return true;
     } else if (typeS.isDartCoreFunction && elementT.getMethod("call") != null) {
       return true;
     }
     InterfaceType supertype = superclass;
     // The type is Object, return false.
     if (supertype != null &&
         (supertype as InterfaceTypeImpl)._isSubtypeOf(
-            typeS,
-            visitedClasses,
-            visitedTypePairs)) {
+            typeS, visitedClasses, visitedTypePairs)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       if ((interfaceType as InterfaceTypeImpl)._isSubtypeOf(
-          typeS,
-          visitedClasses,
-          visitedTypePairs)) {
+          typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     List<InterfaceType> mixinTypes = mixins;
     for (InterfaceType mixinType in mixinTypes) {
       if ((mixinType as InterfaceTypeImpl)._isSubtypeOf(
-          typeS,
-          visitedClasses,
-          visitedTypePairs)) {
+          typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object.
    *
    * @param type the [Type] to compute the longest inheritance path of from the passed
    *          [Type] to Object
    * @return the computed longest inheritance path to Object
    * See [InterfaceType.getLeastUpperBound].
    */
   static int computeLongestInheritancePathToObject(InterfaceType type) =>
-      _computeLongestInheritancePathToObject(type, 0, new HashSet<ClassElement>());
+      _computeLongestInheritancePathToObject(
+          type, 0, new HashSet<ClassElement>());
 
   /**
    * Returns the set of all superinterfaces of the passed [Type].
    *
    * @param type the [Type] to compute the set of superinterfaces of
    * @return the [Set] of superinterfaces of the passed [Type]
    * See [getLeastUpperBound].
    */
   static Set<InterfaceType> computeSuperinterfaceSet(InterfaceType type) =>
       _computeSuperinterfaceSet(type, new HashSet<InterfaceType>());
 
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object. This
    * method calls itself recursively, callers should use the public method
    * [computeLongestInheritancePathToObject].
    *
    * @param type the [Type] to compute the longest inheritance path of from the passed
    *          [Type] to Object
    * @param depth a field used recursively
    * @param visitedClasses the classes that have already been visited
    * @return the computed longest inheritance path to Object
    * See [computeLongestInheritancePathToObject], and [getLeastUpperBound].
    */
-  static int _computeLongestInheritancePathToObject(InterfaceType type,
-      int depth, HashSet<ClassElement> visitedClasses) {
+  static int _computeLongestInheritancePathToObject(
+      InterfaceType type, int depth, HashSet<ClassElement> visitedClasses) {
     ClassElement classElement = type.element;
     // Object case
     if (classElement.supertype == null ||
         visitedClasses.contains(classElement)) {
       return depth;
     }
     int longestPath = 1;
     try {
       visitedClasses.add(classElement);
       List<InterfaceType> superinterfaces = classElement.interfaces;
       int pathLength;
       if (superinterfaces.length > 0) {
         // loop through each of the superinterfaces recursively calling this
         // method and keeping track of the longest path to return
         for (InterfaceType superinterface in superinterfaces) {
           pathLength = _computeLongestInheritancePathToObject(
-              superinterface,
-              depth + 1,
-              visitedClasses);
+              superinterface, depth + 1, visitedClasses);
           if (pathLength > longestPath) {
             longestPath = pathLength;
           }
         }
       }
       // finally, perform this same check on the super type
       // TODO(brianwilkerson) Does this also need to add in the number of mixin
       // classes?
       InterfaceType supertype = classElement.supertype;
-      pathLength =
-          _computeLongestInheritancePathToObject(supertype, depth + 1, visitedClasses);
+      pathLength = _computeLongestInheritancePathToObject(
+          supertype, depth + 1, visitedClasses);
       if (pathLength > longestPath) {
         longestPath = pathLength;
       }
     } finally {
       visitedClasses.remove(classElement);
     }
     return longestPath;
   }
 
   /**
    * Returns the set of all superinterfaces of the passed [Type]. This is a recursive method,
    * callers should call the public [computeSuperinterfaceSet].
    *
    * @param type the [Type] to compute the set of superinterfaces of
    * @param set a [HashSet] used recursively by this method
    * @return the [Set] of superinterfaces of the passed [Type]
    * See [computeSuperinterfaceSet], and [getLeastUpperBound].
    */
-  static Set<InterfaceType> _computeSuperinterfaceSet(InterfaceType type,
-      HashSet<InterfaceType> set) {
+  static Set<InterfaceType> _computeSuperinterfaceSet(
+      InterfaceType type, HashSet<InterfaceType> set) {
     Element element = type.element;
     if (element != null) {
       List<InterfaceType> superinterfaces = type.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
         if (set.add(superinterface)) {
           _computeSuperinterfaceSet(superinterface, set);
         }
       }
       InterfaceType supertype = type.superclass;
       if (supertype != null) {
         if (set.add(supertype)) {
           _computeSuperinterfaceSet(supertype, set);
         }
       }
     }
     return set;
   }
 
   /**
    * Return the intersection of the given sets of types, where intersection is based on the equality
    * of the types themselves.
    *
    * @param first the first set of types to be intersected
    * @param second the second set of types to be intersected
    * @return the intersection of the given sets of types
    */
-  static List<InterfaceType> _intersection(Set<InterfaceType> first,
-      Set<InterfaceType> second) {
+  static List<InterfaceType> _intersection(
+      Set<InterfaceType> first, Set<InterfaceType> second) {
     Set<InterfaceType> result = new HashSet<InterfaceType>.from(first);
     result.retainAll(second);
     return new List.from(result);
   }
 }
 
 /**
  * The interface `LabelElement` defines the behavior of elements representing a label
  * associated with a statement.
  */
@@ skipping 28 matching lines @@
   final bool _onSwitchMember;
 
   /**
    * Initialize a newly created label element to have the given name.
    *
    * @param name the name of this element
    * @param onSwitchStatement `true` if this label is associated with a `switch`
    *          statement
    * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
-  LabelElementImpl(Identifier name, this._onSwitchStatement,
-      this._onSwitchMember)
+  LabelElementImpl(
+      Identifier name, this._onSwitchStatement, this._onSwitchMember)
       : super.forNode(name);
 
   @override
   ExecutableElement get enclosingElement =>
       super.enclosingElement as ExecutableElement;
 
   /**
    * Return `true` if this label is associated with a `switch` member (`case` or
    * `default`).
    *
@@ skipping 232 matching lines @@
 
   @override
   CompilationUnitElement get definingCompilationUnit =>
       _definingCompilationUnit;
 
   /**
    * Set the compilation unit that defines this library to the given compilation unit.
    *
    * @param definingCompilationUnit the compilation unit that defines this library
    */
-  void set
-      definingCompilationUnit(CompilationUnitElement definingCompilationUnit) {
+  void set definingCompilationUnit(
+      CompilationUnitElement definingCompilationUnit) {
     (definingCompilationUnit as CompilationUnitElementImpl).enclosingElement =
         this;
     this._definingCompilationUnit = definingCompilationUnit;
   }
 
   @override
   List<LibraryElement> get exportedLibraries {
     HashSet<LibraryElement> libraries = new HashSet<LibraryElement>();
     for (ExportElement element in _exports) {
       LibraryElement library = element.exportedLibrary;
@@ skipping 144 matching lines @@
   /**
    * Return the object representing the type "Future" from the dart:async library, or the type
    * "void" if the type "Future" cannot be accessed.
    *
    * @return the type "Future" from the dart:async library
    */
   DartType get loadLibraryReturnType {
     try {
       Source asyncSource = context.sourceFactory.forUri(DartSdk.DART_ASYNC);
       if (asyncSource == null) {
-        AnalysisEngine.instance.logger.logError(
-            "Could not create a source for dart:async");
+        AnalysisEngine.instance.logger
+            .logError("Could not create a source for dart:async");
         return VoidTypeImpl.instance;
       }
       LibraryElement asyncElement = context.computeLibraryElement(asyncSource);
       if (asyncElement == null) {
-        AnalysisEngine.instance.logger.logError(
-            "Could not build the element model for dart:async");
+        AnalysisEngine.instance.logger
+            .logError("Could not build the element model for dart:async");
         return VoidTypeImpl.instance;
       }
       ClassElement futureElement = asyncElement.getType("Future");
       if (futureElement == null) {
-        AnalysisEngine.instance.logger.logError(
-            "Could not find type Future in dart:async");
+        AnalysisEngine.instance.logger
+            .logError("Could not find type Future in dart:async");
         return VoidTypeImpl.instance;
       }
       InterfaceType futureType = futureElement.type;
       return futureType.substitute4(<DartType>[DynamicTypeImpl.instance]);
     } on AnalysisException catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logError(
           "Could not build the element model for dart:async",
           new CaughtException(exception, stackTrace));
       return VoidTypeImpl.instance;
     }
@@ skipping 45 matching lines @@
   }
 
   @override
   List<LibraryElement> get visibleLibraries {
     Set<LibraryElement> visibleLibraries = new Set();
     _addVisibleLibraries(visibleLibraries, false);
     return new List.from(visibleLibraries);
   }
 
   @override
-  bool operator ==(Object object) =>
-      object is LibraryElementImpl &&
-          _definingCompilationUnit == object.definingCompilationUnit;
+  bool operator ==(Object object) => object is LibraryElementImpl &&
+      _definingCompilationUnit == object.definingCompilationUnit;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 
   @override
   ElementImpl getChild(String identifier) {
     if ((_definingCompilationUnit as CompilationUnitElementImpl).identifier ==
         identifier) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
@@ skipping 53 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChild(_definingCompilationUnit, visitor);
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
   /**
    * Recursively fills set of visible libraries for [getVisibleElementsLibraries].
    */
-  void _addVisibleLibraries(Set<LibraryElement> visibleLibraries,
-      bool includeExports) {
+  void _addVisibleLibraries(
+      Set<LibraryElement> visibleLibraries, bool includeExports) {
     // maybe already processed
     if (!visibleLibraries.add(this)) {
       return;
     }
     // add imported libraries
     for (ImportElement importElement in _imports) {
       LibraryElement importedLibrary = importElement.importedLibrary;
       if (importedLibrary != null) {
         (importedLibrary as LibraryElementImpl)._addVisibleLibraries(
-            visibleLibraries,
-            true);
+            visibleLibraries, true);
       }
     }
     // add exported libraries
     if (includeExports) {
       for (ExportElement exportElement in _exports) {
         LibraryElement exportedLibrary = exportElement.exportedLibrary;
         if (exportedLibrary != null) {
           (exportedLibrary as LibraryElementImpl)._addVisibleLibraries(
-              visibleLibraries,
-              true);
+              visibleLibraries, true);
         }
       }
     }
   }
 
   /**
    * Determine if the given library is up to date with respect to the given time stamp.
    *
    * @param library the library to process
    * @param timeStamp the time stamp to check against
    * @param visitedLibraries the set of visited libraries
    */
   static bool _safeIsUpToDate(LibraryElement library, int timeStamp,
       Set<LibraryElement> visitedLibraries) {
     if (!visitedLibraries.contains(library)) {
       visitedLibraries.add(library);
       AnalysisContext context = library.context;
       // Check the defining compilation unit.
       if (timeStamp <
-          context.getModificationStamp(library.definingCompilationUnit.source)) {
+          context
+              .getModificationStamp(library.definingCompilationUnit.source)) {
         return false;
       }
       // Check the parted compilation units.
       for (CompilationUnitElement element in library.parts) {
         if (timeStamp < context.getModificationStamp(element.source)) {
           return false;
         }
       }
       // Check the imported libraries.
       for (LibraryElement importedLibrary in library.importedLibraries) {
@@ skipping 32 matching lines @@
    *
    * @return the range of characters in which the name of this element is visible
    */
   SourceRange get visibleRange;
 }
 
 /**
  * The interface `LocalVariableElement` defines the behavior common to elements that represent
  * a local variable.
  */
-abstract class LocalVariableElement implements LocalElement, VariableElement {
-}
+abstract class LocalVariableElement implements LocalElement, VariableElement {}
 
 /**
  * Instances of the class `LocalVariableElementImpl` implement a `LocalVariableElement`.
  */
-class LocalVariableElementImpl extends VariableElementImpl implements
-    LocalVariableElement {
+class LocalVariableElementImpl extends VariableElementImpl
+    implements LocalVariableElement {
   /**
    * An empty list of field elements.
    */
-  static const List<LocalVariableElement> EMPTY_ARRAY = const
-      <LocalVariableElement>[
-      ];
+  static const List<LocalVariableElement> EMPTY_ARRAY =
+      const <LocalVariableElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element does not have a
    * visible range.
    */
@@ skipping 436 matching lines @@
    * If the given method's type is different when any type parameters from the defining type's
    * declaration are replaced with the actual type arguments from the defining type, create a method
    * member representing the given method. Return the member that was created, or the base method if
    * no member was created.
    *
    * @param baseMethod the base method for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the method element that will return the correctly substituted types
    */
-  static MethodElement from(MethodElement baseMethod,
-      InterfaceType definingType) {
+  static MethodElement from(
+      MethodElement baseMethod, InterfaceType definingType) {
     if (baseMethod == null || definingType.typeArguments.length == 0) {
       return baseMethod;
     }
     FunctionType baseType = baseMethod.type;
     List<DartType> argumentTypes = definingType.typeArguments;
     List<DartType> parameterTypes = definingType.element.type.typeArguments;
     FunctionType substitutedType =
         baseType.substitute2(argumentTypes, parameterTypes);
     if (baseType == substitutedType) {
       return baseMethod;
@@ skipping 108 matching lines @@
    */
   static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 17);
 
   /**
    * Indicates that a class was defined using an alias. TODO(brianwilkerson) This should be renamed
    * to 'ALIAS'.
    */
   static const Modifier TYPEDEF = const Modifier('TYPEDEF', 18);
 
   static const List<Modifier> values = const [
-      ABSTRACT,
-      ASYNCHRONOUS,
-      CONST,
-      DEFERRED,
-      ENUM,
-      FACTORY,
-      FINAL,
-      GENERATOR,
-      GETTER,
-      HAS_EXT_URI,
-      MIXIN,
-      MIXIN_ERRORS_REPORTED,
-      POTENTIALLY_MUTATED_IN_CONTEXT,
-      POTENTIALLY_MUTATED_IN_SCOPE,
-      REFERENCES_SUPER,
-      SETTER,
-      STATIC,
-      SYNTHETIC,
-      TYPEDEF];
+    ABSTRACT,
+    ASYNCHRONOUS,
+    CONST,
+    DEFERRED,
+    ENUM,
+    FACTORY,
+    FINAL,
+    GENERATOR,
+    GETTER,
+    HAS_EXT_URI,
+    MIXIN,
+    MIXIN_ERRORS_REPORTED,
+    POTENTIALLY_MUTATED_IN_CONTEXT,
+    POTENTIALLY_MUTATED_IN_SCOPE,
+    REFERENCES_SUPER,
+    SETTER,
+    STATIC,
+    SYNTHETIC,
+    TYPEDEF
+  ];
 
   const Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * The interface `MultiplyDefinedElement` defines the behavior of pseudo-elements that
  * represent multiple elements defined within a single scope that have the same name. This situation
  * is not allowed by the language, so objects implementing this interface always represent an error.
  * As a result, most of the normal operations on elements do not make sense and will return useless
  * results.
@@ skipping 154 matching lines @@
     // There are no children to visit
   }
 
   /**
    * Return an element that represents the given conflicting elements.
    *
    * @param context the analysis context in which the multiply defined elements are defined
    * @param firstElement the first element that conflicts
    * @param secondElement the second element that conflicts
    */
-  static Element fromElements(AnalysisContext context, Element firstElement,
-      Element secondElement) {
+  static Element fromElements(
+      AnalysisContext context, Element firstElement, Element secondElement) {
     List<Element> conflictingElements =
         _computeConflictingElements(firstElement, secondElement);
     int length = conflictingElements.length;
     if (length == 0) {
       return null;
     } else if (length == 1) {
       return conflictingElements[0];
     }
     return new MultiplyDefinedElementImpl(context, conflictingElements);
   }
@@ skipping 17 matching lines @@
 
   /**
    * Use the given elements to construct an array of conflicting elements. If either of the given
    * elements are multiply-defined elements then the conflicting elements they represent will be
    * included in the array. Otherwise, the element itself will be included.
    *
    * @param firstElement the first element to be included
    * @param secondElement the second element to be included
    * @return an array containing all of the conflicting elements
    */
-  static List<Element> _computeConflictingElements(Element firstElement,
-      Element secondElement) {
+  static List<Element> _computeConflictingElements(
+      Element firstElement, Element secondElement) {
     HashSet<Element> elements = new HashSet<Element>();
     _add(elements, firstElement);
     _add(elements, secondElement);
     return new List.from(elements);
   }
 }
 
 /**
  * The interface [MultiplyInheritedExecutableElement] defines all of the behavior of an
  * [ExecutableElement], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
  */
 abstract class MultiplyInheritedExecutableElement implements ExecutableElement {
   /**
    * Return an array containing all of the executable elements defined within this executable
    * element.
    *
    * @return the elements defined within this executable element
    */
   List<ExecutableElement> get inheritedElements;
 }
 
 /**
  * The interface [MultiplyInheritedMethodElementImpl] defines all of the behavior of an
  * [MethodElementImpl], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
  */
-class MultiplyInheritedMethodElementImpl extends MethodElementImpl implements
-    MultiplyInheritedExecutableElement {
+class MultiplyInheritedMethodElementImpl extends MethodElementImpl
+    implements MultiplyInheritedExecutableElement {
   /**
    * An array the array of executable elements that were used to compose this element.
    */
   List<ExecutableElement> _elements = MethodElementImpl.EMPTY_ARRAY;
 
   MultiplyInheritedMethodElementImpl(Identifier name) : super.forNode(name) {
     synthetic = true;
   }
 
   @override
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * The interface [MultiplyInheritedPropertyAccessorElementImpl] defines all of the behavior of
  * an [PropertyAccessorElementImpl], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
  */
-class MultiplyInheritedPropertyAccessorElementImpl extends
-    PropertyAccessorElementImpl implements MultiplyInheritedExecutableElement {
+class MultiplyInheritedPropertyAccessorElementImpl
+    extends PropertyAccessorElementImpl
+    implements MultiplyInheritedExecutableElement {
   /**
    * An array the array of executable elements that were used to compose this element.
    */
   List<ExecutableElement> _elements = PropertyAccessorElementImpl.EMPTY_ARRAY;
 
   MultiplyInheritedPropertyAccessorElementImpl(Identifier name)
       : super.forNode(name) {
     synthetic = true;
   }
 
   @override
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * The interface `NamespaceCombinator` defines the behavior common to objects that control how
  * namespaces are combined.
  */
 abstract class NamespaceCombinator {
   /**
    * An empty list of namespace combinators.
    */
-  static const List<NamespaceCombinator> EMPTY_ARRAY = const
-      <NamespaceCombinator>[
-      ];
+  static const List<NamespaceCombinator> EMPTY_ARRAY =
+      const <NamespaceCombinator>[];
 }
 
 /**
  * The interface `ParameterElement` defines the behavior of elements representing a parameter
  * defined within an executable element.
  */
 abstract class ParameterElement implements LocalElement, VariableElement {
   /**
    * Return the Dart code of the default value, or `null` if no default value.
    *
@@ skipping 20 matching lines @@
    * only define other parameters if it is a function typed parameter.
    *
    * @return the parameters defined by this parameter element
    */
   List<ParameterElement> get parameters;
 }
 
 /**
  * Instances of the class `ParameterElementImpl` implement a `ParameterElement`.
  */
-class ParameterElementImpl extends VariableElementImpl implements
-    ParameterElement {
+class ParameterElementImpl extends VariableElementImpl
+    implements ParameterElement {
   /**
    * An empty list of field elements.
    */
   static const List<ParameterElement> EMPTY_ARRAY = const <ParameterElement>[];
 
   /**
    * An array containing all of the parameters defined by this parameter element. There will only be
    * parameters if this parameter is a function typed parameter.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
@@ skipping 89 matching lines @@
   void appendTo(StringBuffer buffer) {
     String left = "";
     String right = "";
     while (true) {
       if (parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
-      } else if (parameterKind == ParameterKind.REQUIRED) {
-      }
+      } else if (parameterKind == ParameterKind.REQUIRED) {}
       break;
     }
     buffer.write(left);
     appendToWithoutDelimiters(buffer);
     buffer.write(right);
   }
 
   /**
    * Append the type and name of this parameter to the given builder.
    *
@@ skipping 155 matching lines @@
     ParameterElement baseElement = this.baseElement;
     String left = "";
     String right = "";
     while (true) {
       if (baseElement.parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (baseElement.parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
-      } else if (baseElement.parameterKind == ParameterKind.REQUIRED) {
-      }
+      } else if (baseElement.parameterKind == ParameterKind.REQUIRED) {}
       break;
     }
     return '$left$type ${baseElement.displayName}$right';
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(parameters, visitor);
   }
 
   /**
    * If the given parameter's type is different when any type parameters from the defining type's
    * declaration are replaced with the actual type arguments from the defining type, create a
    * parameter member representing the given parameter. Return the member that was created, or the
    * base parameter if no member was created.
    *
    * @param baseParameter the base parameter for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the parameter element that will return the correctly substituted types
    */
-  static ParameterElement from(ParameterElement baseParameter,
-      ParameterizedType definingType) {
+  static ParameterElement from(
+      ParameterElement baseParameter, ParameterizedType definingType) {
     if (baseParameter == null || definingType.typeArguments.length == 0) {
       return baseParameter;
     }
     // Check if parameter type depends on defining type type arguments.
     // It is possible that we did not resolve field formal parameter yet,
     // so skip this check for it.
     bool isFieldFormal = baseParameter is FieldFormalParameterElement;
     if (!isFieldFormal) {
       DartType baseType = baseParameter.type;
       List<DartType> argumentTypes = definingType.typeArguments;
       List<DartType> parameterTypes =
           TypeParameterTypeImpl.getTypes(definingType.typeParameters);
       DartType substitutedType =
           baseType.substitute2(argumentTypes, parameterTypes);
       if (baseType == substitutedType) {
         return baseParameter;
       }
     }
     // TODO(brianwilkerson) Consider caching the substituted type in the
     // instance. It would use more memory but speed up some operations.
     // We need to see how often the type is being re-computed.
     if (isFieldFormal) {
       return new FieldFormalParameterMember(
-          baseParameter as FieldFormalParameterElement,
-          definingType);
+          baseParameter as FieldFormalParameterElement, definingType);
     }
     return new ParameterMember(baseParameter, definingType);
   }
 }
 
 /**
  * The interface `PrefixElement` defines the behavior common to elements that represent a
  * prefix used to import one or more libraries into another library.
  */
 abstract class PrefixElement implements Element {
@@ skipping 138 matching lines @@
    *
    * @return the variable associated with this accessor
    */
   PropertyInducingElement get variable;
 }
 
 /**
  * Instances of the class `PropertyAccessorElementImpl` implement a
  * `PropertyAccessorElement`.
  */
-class PropertyAccessorElementImpl extends ExecutableElementImpl implements
-    PropertyAccessorElement {
+class PropertyAccessorElementImpl extends ExecutableElementImpl
+    implements PropertyAccessorElement {
   /**
    * An empty list of property accessor elements.
    */
-  static const List<PropertyAccessorElement> EMPTY_ARRAY = const
-      <PropertyAccessorElement>[
-      ];
+  static const List<PropertyAccessorElement> EMPTY_ARRAY =
+      const <PropertyAccessorElement>[];
 
   /**
    * The variable associated with this accessor.
    */
   PropertyInducingElement variable;
 
   /**
    * Initialize a newly created property accessor element to have the given name.
    *
    * @param name the name of this element
@@ skipping 111 matching lines @@
   /**
    * Set whether this accessor is static to correspond to the given value.
    *
    * @param isStatic `true` if the accessor is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
-  bool operator ==(Object object) =>
-      super == object && isGetter == (object as PropertyAccessorElement).isGetter;
+  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);
   }
 }
 
 /**
  * Instances of the class `PropertyAccessorMember` represent a property accessor element
  * defined in a parameterized type where the values of the type parameters are known.
  */
-class PropertyAccessorMember extends ExecutableMember implements
-    PropertyAccessorElement {
+class PropertyAccessorMember extends ExecutableMember
+    implements PropertyAccessorElement {
   /**
    * Initialize a newly created element to represent a property accessor of the given parameterized
    * type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  PropertyAccessorMember(PropertyAccessorElement baseElement,
-      InterfaceType definingType)
+  PropertyAccessorMember(
+      PropertyAccessorElement baseElement, InterfaceType definingType)
       : super(baseElement, definingType);
 
   @override
   PropertyAccessorElement get baseElement =>
       super.baseElement as PropertyAccessorElement;
 
   @override
   PropertyAccessorElement get correspondingGetter =>
       from(baseElement.correspondingGetter, definingType);
 
@@ skipping 62 matching lines @@
    * If the given property accessor's type is different when any type parameters from the defining
    * type's declaration are replaced with the actual type arguments from the defining type, create a
    * property accessor member representing the given property accessor. Return the member that was
    * created, or the base accessor if no member was created.
    *
    * @param baseAccessor the base property accessor for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the property accessor element that will return the correctly substituted types
    */
-  static PropertyAccessorElement from(PropertyAccessorElement baseAccessor,
-      InterfaceType definingType) {
+  static PropertyAccessorElement from(
+      PropertyAccessorElement baseAccessor, InterfaceType definingType) {
     if (!_isChangedByTypeSubstitution(baseAccessor, definingType)) {
       return baseAccessor;
     }
     // TODO(brianwilkerson) Consider caching the substituted type in the
     // instance. It would use more memory but speed up some operations.
     // We need to see how often the type is being re-computed.
     return new PropertyAccessorMember(baseAccessor, definingType);
   }
 
   /**
    * Determine whether the given property accessor's type is changed when type parameters from the
    * defining type's declaration are replaced with the actual type arguments from the defining type.
    *
    * @param baseAccessor the base property accessor
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return true if the type is changed by type substitution.
    */
-  static bool _isChangedByTypeSubstitution(PropertyAccessorElement baseAccessor,
-      InterfaceType definingType) {
+  static bool _isChangedByTypeSubstitution(
+      PropertyAccessorElement baseAccessor, InterfaceType definingType) {
     List<DartType> argumentTypes = definingType.typeArguments;
     if (baseAccessor != null && argumentTypes.length != 0) {
       FunctionType baseType = baseAccessor.type;
       if (baseType == null) {
         AnalysisEngine.instance.logger.logInformation(
             'Type of $baseAccessor is null in PropertyAccessorMember._isChangedByTypeSubstitution');
         return false;
       }
       List<DartType> parameterTypes = definingType.element.type.typeArguments;
       FunctionType substitutedType =
@@ skipping 73 matching lines @@
 
 /**
  * Instances of the class `PropertyInducingElementImpl` implement a
  * `PropertyInducingElement`.
  */
 abstract class PropertyInducingElementImpl extends VariableElementImpl
     implements PropertyInducingElement {
   /**
    * An empty list of elements.
    */
-  static const List<PropertyInducingElement> EMPTY_ARRAY = const
-      <PropertyInducingElement>[
-      ];
+  static const List<PropertyInducingElement> EMPTY_ARRAY =
+      const <PropertyInducingElement>[];
 
   /**
    * The getter associated with this element.
    */
   PropertyAccessorElement getter;
 
   /**
    * The setter associated with this element, or `null` if the element is effectively
    * `final` and therefore does not have a setter associated with it.
    */
@@ skipping 303 matching lines @@
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
 
   @override
   R visitTypeParameterElement(TypeParameterElement element) => null;
 }
 
 /**
  * The interface `TopLevelVariableElement` defines the behavior of elements representing a
  * top-level variable.
  */
-abstract class TopLevelVariableElement implements PropertyInducingElement {
-}
+abstract class TopLevelVariableElement implements PropertyInducingElement {}
 
 /**
  * Instances of the class `TopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement`.
  */
-class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements
-    TopLevelVariableElement {
+class TopLevelVariableElementImpl extends PropertyInducingElementImpl
+    implements TopLevelVariableElement {
   /**
    * An empty list of top-level variable elements.
    */
-  static const List<TopLevelVariableElement> EMPTY_ARRAY = const
-      <TopLevelVariableElement>[
-      ];
+  static const List<TopLevelVariableElement> EMPTY_ARRAY =
+      const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   TopLevelVariableElementImpl(String name, int nameOffset)
       : super(name, nameOffset);
@@ skipping 84 matching lines @@
     }
   }
 
   @override
   DartType getLeastUpperBound(DartType type) => null;
 
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs);
 
   int internalHashCode(List<DartType> visitedTypes);
 
-  bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
-      Set<TypeImpl_TypePair> visitedTypePairs);
+  bool internalIsMoreSpecificThan(
+      DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs);
 
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs);
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs);
 
   @override
   bool isAssignableTo(DartType type) =>
       isAssignableTo2(type, new HashSet<TypeImpl_TypePair>());
 
   /**
    * Return `true` if this type is assignable to the given type. A type <i>T</i> may be
    * assigned to a type <i>S</i>, written <i>T</i> &hArr; <i>S</i>, iff either <i>T</i> <: <i>S</i>
    * or <i>S</i> <: <i>T</i> (Interface Types section of spec).
    *
@@ skipping 118 matching lines @@
    * of type arguments are all equal. Use the set of [visitedElementPairs] to
    * prevent infinite loops when the types are recursively defined.
    */
   static bool equalArrays(List<DartType> first, List<DartType> second,
       Set<ElementPair> visitedElementPairs) {
     if (first.length != second.length) {
       return false;
     }
     for (int i = 0; i < first.length; i++) {
       if (first[i] == null) {
-        AnalysisEngine.instance.logger.logInformation(
-            'Found null type argument in TypeImpl.equalArrays');
+        AnalysisEngine.instance.logger
+            .logInformation('Found null type argument in TypeImpl.equalArrays');
         return second[i] == null;
       } else if (second[i] == null) {
-        AnalysisEngine.instance.logger.logInformation(
-            'Found null type argument in TypeImpl.equalArrays');
+        AnalysisEngine.instance.logger
+            .logInformation('Found null type argument in TypeImpl.equalArrays');
         return false;
       }
       if (!(first[i] as TypeImpl).internalEquals(
-          second[i],
-          visitedElementPairs)) {
+          second[i], visitedElementPairs)) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Return an array containing the results of using the given argument types and parameter types to
    * perform a substitution on all of the given types.
    *
@@ skipping 75 matching lines @@
    * Return the type defined by this type parameter.
    *
    * @return the type defined by this type parameter
    */
   TypeParameterType get type;
 }
 
 /**
  * Instances of the class `TypeParameterElementImpl` implement a [TypeParameterElement].
  */
-class TypeParameterElementImpl extends ElementImpl implements
-    TypeParameterElement {
+class TypeParameterElementImpl extends ElementImpl
+    implements TypeParameterElement {
   /**
    * An empty list of type parameter elements.
    */
-  static const List<TypeParameterElement> EMPTY_ARRAY = const
-      <TypeParameterElement>[
-      ];
+  static const List<TypeParameterElement> EMPTY_ARRAY =
+      const <TypeParameterElement>[];
 
   /**
    * The type defined by this type parameter.
    */
   TypeParameterType type;
 
   /**
    * The type representing the bound associated with this parameter, or `null` if this
    * parameter does not have an explicit bound.
    */
@@ skipping 43 matching lines @@
 
 /**
  * Instances of the class `TypeParameterTypeImpl` defines the behavior of objects representing
  * the type introduced by a type parameter.
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
    * An empty list of type parameter types.
    */
   static const List<TypeParameterType> EMPTY_ARRAY = const <TypeParameterType>[
-      ];
+  ];
 
   /**
    * Initialize a newly created type parameter type to be declared by the given element and to have
    * the given name.
    *
    * @param element the element representing the declaration of the type parameter
    */
   TypeParameterTypeImpl(TypeParameterElement element)
       : super(element, element.name);
 
   @override
   TypeParameterElement get element => super.element as TypeParameterElement;
 
   @override
   int get hashCode => element.hashCode;
 
   @override
   bool operator ==(Object object) =>
       object is TypeParameterTypeImpl && (element == object.element);
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       this == object;
 
   @override
   int internalHashCode(List<DartType> visitedTypes) => hashCode;
 
   @override
-  bool internalIsMoreSpecificThan(DartType s, bool withDynamic,
-      Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool internalIsMoreSpecificThan(
+      DartType s, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // A type T is more specific than a type S, written T << S,
     // if one of the following conditions is met:
     //
     // Reflexivity: T is S.
     //
     if (this == s) {
       return true;
     }
     // S is dynamic.
     //
     if (s.isDynamic) {
       return true;
     }
     return _isMoreSpecificThan(
-        s,
-        new HashSet<DartType>(),
-        withDynamic,
-        visitedTypePairs);
+        s, new HashSet<DartType>(), withDynamic, visitedTypePairs);
   }
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) =>
+  bool internalIsSubtypeOf(
+          DartType type, Set<TypeImpl_TypePair> visitedTypePairs) =>
       isMoreSpecificThan2(type, true, new HashSet<TypeImpl_TypePair>());
 
   @override
-  DartType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) {
+  DartType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
 
   bool _isMoreSpecificThan(DartType s, Set<DartType> visitedTypes,
@@ skipping 20 matching lines @@
     //
     if (bound is TypeParameterTypeImpl) {
       TypeParameterTypeImpl boundTypeParameter = bound;
       // First check for infinite loops
       if (visitedTypes.contains(bound)) {
         return false;
       }
       visitedTypes.add(bound);
       // Then check upper bound.
       return boundTypeParameter._isMoreSpecificThan(
-          s,
-          visitedTypes,
-          withDynamic,
-          visitedTypePairs);
+          s, visitedTypes, withDynamic, visitedTypePairs);
     }
     // Check interface type.
     return (bound as TypeImpl).isMoreSpecificThan2(
-        s,
-        withDynamic,
-        visitedTypePairs);
+        s, withDynamic, visitedTypePairs);
   }
 
   /**
    * Return an array containing the type parameter types defined by the given array of type
    * parameter elements.
    *
    * @param typeParameters the type parameter elements defining the type parameter types to be
    *          returned
    * @return the type parameter types defined by the type parameter elements
    */
-  static List<TypeParameterType>
-      getTypes(List<TypeParameterElement> typeParameters) {
+  static List<TypeParameterType> getTypes(
+      List<TypeParameterElement> typeParameters) {
     int count = typeParameters.length;
     if (count == 0) {
       return EMPTY_ARRAY;
     }
     List<TypeParameterType> types = new List<TypeParameterType>(count);
     for (int i = 0; i < count; i++) {
       types[i] = typeParameters[i].type;
     }
     return types;
   }
 }
 
 /**
  * The interface `UndefinedElement` defines the behavior of pseudo-elements that represent
  * names that are undefined. This situation is not allowed by the language, so objects implementing
  * this interface always represent an error. As a result, most of the normal operations on elements
  * do not make sense and will return useless results.
  */
-abstract class UndefinedElement implements Element {
-}
+abstract class UndefinedElement implements Element {}
 
 /**
  * The unique instance of the class `UndefinedTypeImpl` implements the type of
  * typenames that couldn't be resolved.
  *
  * This class behaves like DynamicTypeImpl in almost every respect, to reduce
  * cascading errors.
  */
 class UndefinedTypeImpl extends TypeImpl {
   /**
@@ skipping 38 matching lines @@
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is S
     if (identical(this, type)) {
       return true;
     }
     // else
     return withDynamic;
   }
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) =>
-      true;
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 
   @override
   bool isSupertypeOf(DartType type) => true;
 
   @override
-  DartType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) {
+  DartType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
 }
 
@@ skipping 80 matching lines @@
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // What version of subtyping do we want? See discussion below in
     // [internalIsSubtypeOf].
     if (AnalysisEngine.instance.strictUnionTypes) {
       // The less unsound version: all.
       for (DartType t in _types) {
         if (!(t as TypeImpl).internalIsMoreSpecificThan(
-            type,
-            withDynamic,
-            visitedTypePairs)) {
+            type, withDynamic, visitedTypePairs)) {
           return false;
         }
       }
       return true;
     } else {
       // The more unsound version: any.
       for (DartType t in _types) {
         if ((t as TypeImpl).internalIsMoreSpecificThan(
-            type,
-            withDynamic,
-            visitedTypePairs)) {
+            type, withDynamic, visitedTypePairs)) {
           return true;
         }
       }
       return false;
     }
   }
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     if (AnalysisEngine.instance.strictUnionTypes) {
       // The less unsound version: all.
       //
       // For this version to make sense we also need to redefine assignment
       // compatibility [<=>].
       // See discussion above.
       for (DartType t in _types) {
         if (!(t as TypeImpl).internalIsSubtypeOf(type, visitedTypePairs)) {
           return false;
         }
@@ skipping 22 matching lines @@
   bool internalUnionTypeIsLessSpecificThan(DartType type, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     // This implementation does not make sense when [type] is a union type,
     // at least for the "less unsound" version of [internalIsMoreSpecificThan]
     // above.
     if (type is UnionType) {
       throw new IllegalArgumentException("Only non-union types are supported.");
     }
     for (DartType t in _types) {
       if ((type as TypeImpl).internalIsMoreSpecificThan(
-          t,
-          withDynamic,
-          visitedTypePairs)) {
+          t, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * The supertype test for union types is uniform in non-union subtypes. So, other `TypeImpl`
    * s can call this method to implement `internalIsSubtypeOf` for union types.
    *
    * @param type
    * @param visitedTypePairs
    * @return true if this union type is a super type of `type`
    */
-  bool internalUnionTypeIsSuperTypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool internalUnionTypeIsSuperTypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     // This implementation does not make sense when [type] is a union type,
     // at least for the "less unsound" version of [internalIsSubtypeOf] above.
     if (type is UnionType) {
       throw new IllegalArgumentException("Only non-union types are supported.");
     }
     for (DartType t in _types) {
       if ((type as TypeImpl).internalIsSubtypeOf(t, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
   @override
-  DartType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) {
+  DartType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) {
     List<DartType> out = new List<DartType>();
     for (DartType t in _types) {
       out.add(t.substitute2(argumentTypes, parameterTypes));
     }
     return union(out);
   }
 
   /**
    * Any unions in the `types` will be flattened in the returned union. If there is only one
    * type after flattening then it will be returned directly, instead of a singleton union. Nulls
@@ skipping 54 matching lines @@
    *
    * @return the offset of the URI
    */
   int get uriOffset;
 }
 
 /**
  * Instances of the class `UriReferencedElementImpl` implement an [UriReferencedElement]
  * .
  */
-abstract class UriReferencedElementImpl extends ElementImpl implements
-    UriReferencedElement {
+abstract class UriReferencedElementImpl extends ElementImpl
+    implements UriReferencedElement {
   /**
    * The offset of the URI in the file, may be `-1` if synthetic.
    */
   int uriOffset = -1;
 
   /**
    * The offset of the character immediately following the last character of this node's URI, may be
    * `-1` if synthetic.
    */
   int uriEnd = -1;
@@ skipping 59 matching lines @@
    * declared type (such as if it was declared using the keyword 'var').
    *
    * @return the declared type of this variable
    */
   DartType get type;
 }
 
 /**
  * Instances of the class `VariableElementImpl` implement a `VariableElement`.
  */
-abstract class VariableElementImpl extends ElementImpl implements
-    VariableElement {
+abstract class VariableElementImpl extends ElementImpl
+    implements VariableElement {
   /**
    * An empty list of variable elements.
    */
   static const List<VariableElement> EMPTY_ARRAY = const <VariableElement>[];
 
   /**
    * The declared type of this variable.
    */
   DartType type;
 
@@ skipping 163 matching lines @@
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
   @override
-  VoidType substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes);
+  VoidType substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes);
 }
 
 /**
  * The unique instance of the class `VoidTypeImpl` implements the type `void`.
  */
 class VoidTypeImpl extends TypeImpl implements VoidType {
   /**
    * The unique instance of this class.
    */
   static VoidTypeImpl _INSTANCE = new VoidTypeImpl();
@@ skipping 21 matching lines @@
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) =>
       identical(object, this);
 
   @override
   int internalHashCode(List<DartType> visitedTypes) => hashCode;
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic,
-      Set<TypeImpl_TypePair> visitedTypePairs) =>
-      isSubtypeOf(type);
+      Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf(type);
 
   @override
-  bool internalIsSubtypeOf(DartType type,
-      Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool internalIsSubtypeOf(
+      DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(
-          this,
-          visitedTypePairs);
+          this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
-  VoidTypeImpl substitute2(List<DartType> argumentTypes,
-      List<DartType> parameterTypes) =>
-      this;
+  VoidTypeImpl substitute2(
+      List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }