Move the remainder of generated/element.dart into better locations

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 library is deprecated. Please convert all references to this library to
+ * reference one of the following public libraries:
+ * * package:analyzer/dart/element/element.dart
+ * * package:analyzer/dart/element/type.dart
+ * * package:analyzer/dart/element/visitor.dart
+ *
+ * If your code is using API's not available in these public libraries, please
+ * contact the analyzer team to either find an alternate API or have the API you
+ * depend on added to the public API.
+ */
 library analyzer.src.generated.element;
 
-import 'dart:collection';
-import 'dart:math' show min;
-
-import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/dart/element/visitor.dart';
-import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/constant.dart'
-    show DartObject, EvaluationResultImpl;
-import 'package:analyzer/src/generated/engine.dart'
-    show AnalysisContext, AnalysisEngine, AnalysisException;
-import 'package:analyzer/src/generated/java_core.dart';
-import 'package:analyzer/src/generated/java_engine.dart';
-import 'package:analyzer/src/generated/resolver.dart';
-import 'package:analyzer/src/generated/scanner.dart' show Keyword;
-import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
-import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/utilities_collection.dart';
-import 'package:analyzer/src/generated/utilities_dart.dart';
-import 'package:analyzer/src/generated/utilities_general.dart';
-
 export 'package:analyzer/dart/element/element.dart';
 export 'package:analyzer/dart/element/type.dart';
 export 'package:analyzer/dart/element/visitor.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]. Because
- * 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 been resolved or if the node could not be resolved.
-   */
-  final ExecutableElement propagatedElement;
-
-  /**
-   * The element based on static type information, or `null` if the AST
-   * structure has not been resolved or if the node could not be resolved.
-   */
-  final ExecutableElement staticElement;
-
-  /**
-   * Initialize a newly created pair to have both the [staticElement] and the
-   * [propagatedElement].
-   */
-  AuxiliaryElements(this.staticElement, this.propagatedElement);
-}
-
-/**
- * A [Type] that represents the type 'bottom'.
- */
-class BottomTypeImpl extends TypeImpl {
-  /**
-   * The unique instance of this class.
-   */
-  static BottomTypeImpl _INSTANCE = new BottomTypeImpl._();
-
-  /**
-   * Return the unique instance of this class.
-   */
-  static BottomTypeImpl get instance => _INSTANCE;
-
-  /**
-   * Prevent the creation of instances of this class.
-   */
-  BottomTypeImpl._() : super(null, "<bottom>");
-
-  @override
-  int get hashCode => 0;
-
-  @override
-  bool get isBottom => true;
-
-  @override
-  bool operator ==(Object object) => identical(object, this);
-
-  @override
-  bool isMoreSpecificThan(DartType type,
-          [bool withDynamic = false, Set<Element> visitedElements]) =>
-      true;
-
-  @override
-  bool isSubtypeOf(DartType type) => true;
-
-  @override
-  bool isSupertypeOf(DartType type) => false;
-
-  @override
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
-
-  @override
-  BottomTypeImpl substitute2(
-          List<DartType> argumentTypes, List<DartType> parameterTypes,
-          [List<FunctionTypeAliasElement> prune]) =>
-      this;
-}
-
-/**
- * Type created internally if a circular reference is ever detected.  Behaves
- * like `dynamic`, except that when converted to a string it is displayed as
- * `...`.
- */
-class CircularTypeImpl extends DynamicTypeImpl {
-  CircularTypeImpl() : super._circular();
-
-  @override
-  int get hashCode => 1;
-
-  @override
-  bool operator ==(Object object) => object is CircularTypeImpl;
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write('...');
-  }
-
-  @override
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
-}
-
-/**
- * A concrete implementation of a [ClassElement].
- */
-class ClassElementImpl extends ElementImpl implements ClassElement {
-  /**
-   * A list containing all of the accessors (getters and setters) contained in
-   * this class.
-   */
-  List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
-
-  /**
-   * For classes which are not mixin applications, a list containing all of the
-   * constructors contained in this class, or `null` if the list of
-   * constructors has not yet been built.
-   *
-   * For classes which are mixin applications, the list of constructors is
-   * computed on the fly by the [constructors] getter, and this field is
-   * `null`.
-   */
-  List<ConstructorElement> _constructors;
-
-  /**
-   * A list containing all of the fields contained in this class.
-   */
-  List<FieldElement> _fields = FieldElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the mixins that are applied to the class being
-   * extended in order to derive the superclass of this class.
-   */
-  List<InterfaceType> mixins = InterfaceType.EMPTY_LIST;
-
-  /**
-   * A list containing all of the interfaces that are implemented by this class.
-   */
-  List<InterfaceType> interfaces = InterfaceType.EMPTY_LIST;
-
-  /**
-   * A list containing all of the methods contained in this class.
-   */
-  List<MethodElement> _methods = MethodElement.EMPTY_LIST;
-
-  /**
-   * The superclass of the class, or `null` if the class does not have an
-   * explicit superclass.
-   */
-  InterfaceType supertype;
-
-  /**
-   * The type defined by the class.
-   */
-  InterfaceType type;
-
-  /**
-   * A list containing all of the type parameters defined for this class.
-   */
-  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
-
-  /**
-   * The [SourceRange] of the `with` clause, `null` if there is no one.
-   */
-  SourceRange withClauseRange;
-
-  /**
-   * A flag indicating whether the types associated with the instance members of
-   * this class have been inferred.
-   */
-  bool hasBeenInferred = false;
-
-  /**
-   * Initialize a newly created class element to have the given [name] at the
-   * given [offset] in the file that contains the declaration of this element.
-   */
-  ClassElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created class element to have the given [name].
-   */
-  ClassElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  /**
-   * Set whether this class is abstract.
-   */
-  void set abstract(bool isAbstract) {
-    setModifier(Modifier.ABSTRACT, isAbstract);
-  }
-
-  @override
-  List<PropertyAccessorElement> get accessors => _accessors;
-
-  /**
-   * Set the accessors contained in this class to the given [accessors].
-   */
-  void set accessors(List<PropertyAccessorElement> accessors) {
-    for (PropertyAccessorElement accessor in accessors) {
-      (accessor as PropertyAccessorElementImpl).enclosingElement = this;
-    }
-    this._accessors = accessors;
-  }
-
-  @override
-  List<InterfaceType> get allSupertypes {
-    List<InterfaceType> list = new List<InterfaceType>();
-    _collectAllSupertypes(list);
-    return list;
-  }
-
-  @override
-  List<ConstructorElement> get constructors {
-    if (!isMixinApplication) {
-      assert(_constructors != null);
-      return _constructors == null
-          ? ConstructorElement.EMPTY_LIST
-          : _constructors;
-    }
-
-    return _computeMixinAppConstructors();
-  }
-
-  /**
-   * Set the constructors contained in this class to the given [constructors].
-   *
-   * Should only be used for class elements that are not mixin applications.
-   */
-  void set constructors(List<ConstructorElement> constructors) {
-    assert(!isMixinApplication);
-    for (ConstructorElement constructor in constructors) {
-      (constructor as ConstructorElementImpl).enclosingElement = this;
-    }
-    this._constructors = constructors;
-  }
-
-  /**
-   * Return `true` if [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS] should
-   * be reported for this class.
-   */
-  bool get doesMixinLackConstructors {
-    if (!isMixinApplication && mixins.isEmpty) {
-      // This class is not a mixin application and it doesn't have a "with"
-      // clause, so CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS is
-      // inapplicable.
-      return false;
-    }
-    if (supertype == null) {
-      // Should never happen, since Object is the only class that has no
-      // supertype, and it should have been caught by the test above.
-      assert(false);
-      return false;
-    }
-    // Find the nearest class in the supertype chain that is not a mixin
-    // application.
-    ClassElement nearestNonMixinClass = supertype.element;
-    if (nearestNonMixinClass.isMixinApplication) {
-      // Use a list to keep track of the classes we've seen, so that we won't
-      // go into an infinite loop in the event of a non-trivial loop in the
-      // class hierarchy.
-      List<ClassElementImpl> classesSeen = <ClassElementImpl>[this];
-      while (nearestNonMixinClass.isMixinApplication) {
-        if (classesSeen.contains(nearestNonMixinClass)) {
-          // Loop in the class hierarchy (which is reported elsewhere).  Don't
-          // confuse the user with further errors.
-          return false;
-        }
-        classesSeen.add(nearestNonMixinClass);
-        if (nearestNonMixinClass.supertype == null) {
-          // Should never happen, since Object is the only class that has no
-          // supertype, and it is not a mixin application.
-          assert(false);
-          return false;
-        }
-        nearestNonMixinClass = nearestNonMixinClass.supertype.element;
-      }
-    }
-    return !nearestNonMixinClass.constructors.any(isSuperConstructorAccessible);
-  }
-
-  /**
-   * Set whether this class is defined by an enum declaration.
-   */
-  void set enum2(bool isEnum) {
-    setModifier(Modifier.ENUM, isEnum);
-  }
-
-  @override
-  List<FieldElement> get fields => _fields;
-
-  /**
-   * Set the fields contained in this class to the given [fields].
-   */
-  void set fields(List<FieldElement> fields) {
-    for (FieldElement field in fields) {
-      (field as FieldElementImpl).enclosingElement = this;
-    }
-    this._fields = fields;
-  }
-
-  @override
-  bool get hasNonFinalField {
-    List<ClassElement> classesToVisit = new List<ClassElement>();
-    HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
-    classesToVisit.add(this);
-    while (!classesToVisit.isEmpty) {
-      ClassElement currentElement = classesToVisit.removeAt(0);
-      if (visitedClasses.add(currentElement)) {
-        // check fields
-        for (FieldElement field in currentElement.fields) {
-          if (!field.isFinal &&
-              !field.isConst &&
-              !field.isStatic &&
-              !field.isSynthetic) {
-            return true;
-          }
-        }
-        // check mixins
-        for (InterfaceType mixinType in currentElement.mixins) {
-          ClassElement mixinElement = mixinType.element;
-          classesToVisit.add(mixinElement);
-        }
-        // check super
-        InterfaceType supertype = currentElement.supertype;
-        if (supertype != null) {
-          ClassElement superElement = supertype.element;
-          if (superElement != null) {
-            classesToVisit.add(superElement);
-          }
-        }
-      }
-    }
-    // not found
-    return false;
-  }
-
-  @override
-  bool get hasReferenceToSuper => hasModifier(Modifier.REFERENCES_SUPER);
-
-  /**
-   * Set whether this class references 'super'.
-   */
-  void set hasReferenceToSuper(bool isReferencedSuper) {
-    setModifier(Modifier.REFERENCES_SUPER, isReferencedSuper);
-  }
-
-  @override
-  bool get hasStaticMember {
-    for (MethodElement method in _methods) {
-      if (method.isStatic) {
-        return true;
-      }
-    }
-    for (PropertyAccessorElement accessor in _accessors) {
-      if (accessor.isStatic) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
-
-  @override
-  bool get isEnum => hasModifier(Modifier.ENUM);
-
-  @override
-  bool get isMixinApplication => hasModifier(Modifier.MIXIN_APPLICATION);
-
-  @override
-  bool get isOrInheritsProxy =>
-      _safeIsOrInheritsProxy(this, new HashSet<ClassElement>());
-
-  @override
-  bool get isProxy {
-    for (ElementAnnotation annotation in metadata) {
-      if (annotation.isProxy) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  bool get isValidMixin => hasModifier(Modifier.MIXIN);
-
-  @override
-  ElementKind get kind => ElementKind.CLASS;
-
-  @override
-  List<MethodElement> get methods => _methods;
-
-  /**
-   * Set the methods contained in this class to the given [methods].
-   */
-  void set methods(List<MethodElement> methods) {
-    for (MethodElement method in methods) {
-      (method as MethodElementImpl).enclosingElement = this;
-    }
-    this._methods = methods;
-  }
-
-  /**
-   * Set whether this class is a mixin application.
-   */
-  void set mixinApplication(bool isMixinApplication) {
-    setModifier(Modifier.MIXIN_APPLICATION, isMixinApplication);
-  }
-
-  @override
-  List<TypeParameterElement> get typeParameters => _typeParameters;
-
-  /**
-   * Set the type parameters defined for this class to the given
-   * [typeParameters].
-   */
-  void set typeParameters(List<TypeParameterElement> typeParameters) {
-    for (TypeParameterElement typeParameter in typeParameters) {
-      (typeParameter as TypeParameterElementImpl).enclosingElement = this;
-    }
-    this._typeParameters = typeParameters;
-  }
-
-  @override
-  ConstructorElement get unnamedConstructor {
-    for (ConstructorElement element in constructors) {
-      String name = element.displayName;
-      if (name == null || name.isEmpty) {
-        return element;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Set whether this class is a valid mixin.
-   */
-  void set validMixin(bool isValidMixin) {
-    setModifier(Modifier.MIXIN, isValidMixin);
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitClassElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    if (isAbstract) {
-      buffer.write('abstract ');
-    }
-    buffer.write('class ');
-    String name = displayName;
-    if (name == null) {
-      buffer.write("{unnamed class}");
-    } else {
-      buffer.write(name);
-    }
-    int variableCount = _typeParameters.length;
-    if (variableCount > 0) {
-      buffer.write("<");
-      for (int i = 0; i < variableCount; i++) {
-        if (i > 0) {
-          buffer.write(", ");
-        }
-        (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
-      }
-      buffer.write(">");
-    }
-    if (supertype != null && !supertype.isObject) {
-      buffer.write(' extends ');
-      buffer.write(supertype.displayName);
-    }
-    if (mixins.isNotEmpty) {
-      buffer.write(' with ');
-      buffer.write(mixins.map((t) => t.displayName).join(', '));
-    }
-    if (interfaces.isNotEmpty) {
-      buffer.write(' implements ');
-      buffer.write(interfaces.map((t) => t.displayName).join(', '));
-    }
-  }
-
-  @override
-  NamedCompilationUnitMember computeNode() {
-    if (isEnum) {
-      return getNodeMatching((node) => node is EnumDeclaration);
-    } else {
-      return getNodeMatching(
-          (node) => node is ClassDeclaration || node is ClassTypeAlias);
-    }
-  }
-
-  @override
-  ElementImpl getChild(String identifier) {
-    //
-    // The casts in this method are safe because the set methods would have
-    // thrown a CCE if any of the elements in the arrays were not of the
-    // expected types.
-    //
-    for (PropertyAccessorElement accessor in _accessors) {
-      if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
-        return accessor as PropertyAccessorElementImpl;
-      }
-    }
-    for (ConstructorElement constructor in _constructors) {
-      if ((constructor as ConstructorElementImpl).identifier == identifier) {
-        return constructor as ConstructorElementImpl;
-      }
-    }
-    for (FieldElement field in _fields) {
-      if ((field as FieldElementImpl).identifier == identifier) {
-        return field as FieldElementImpl;
-      }
-    }
-    for (MethodElement method in _methods) {
-      if ((method as MethodElementImpl).identifier == identifier) {
-        return method as MethodElementImpl;
-      }
-    }
-    for (TypeParameterElement typeParameter in _typeParameters) {
-      if ((typeParameter as TypeParameterElementImpl).identifier ==
-          identifier) {
-        return typeParameter as TypeParameterElementImpl;
-      }
-    }
-    return null;
-  }
-
-  @override
-  FieldElement getField(String name) {
-    for (FieldElement fieldElement in _fields) {
-      if (name == fieldElement.name) {
-        return fieldElement;
-      }
-    }
-    return null;
-  }
-
-  @override
-  PropertyAccessorElement getGetter(String getterName) {
-    for (PropertyAccessorElement accessor in _accessors) {
-      if (accessor.isGetter && accessor.name == getterName) {
-        return accessor;
-      }
-    }
-    return null;
-  }
-
-  @override
-  MethodElement getMethod(String methodName) {
-    for (MethodElement method in _methods) {
-      if (method.name == methodName) {
-        return method;
-      }
-    }
-    return null;
-  }
-
-  @override
-  ConstructorElement getNamedConstructor(String name) {
-    for (ConstructorElement element in constructors) {
-      String elementName = element.name;
-      if (elementName != null && elementName == name) {
-        return element;
-      }
-    }
-    return null;
-  }
-
-  @override
-  PropertyAccessorElement getSetter(String setterName) {
-    // TODO (jwren) revisit- should we append '=' here or require clients to
-    // include it?
-    // Do we need the check for isSetter below?
-    if (!StringUtilities.endsWithChar(setterName, 0x3D)) {
-      setterName += '=';
-    }
-    for (PropertyAccessorElement accessor in _accessors) {
-      if (accessor.isSetter && accessor.name == setterName) {
-        return accessor;
-      }
-    }
-    return null;
-  }
-
-  @override
-  bool isSuperConstructorAccessible(ConstructorElement constructor) {
-    // If this class has no mixins, then all superclass constructors are
-    // accessible.
-    if (mixins.isEmpty) {
-      return true;
-    }
-    // Otherwise only constructors that lack optional parameters are
-    // 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) =>
-      _internalLookUpConcreteMethod(methodName, library, true);
-
-  @override
-  PropertyAccessorElement lookUpGetter(
-          String getterName, LibraryElement library) =>
-      _internalLookUpGetter(getterName, library, true);
-
-  @override
-  PropertyAccessorElement lookUpInheritedConcreteGetter(
-          String getterName, LibraryElement library) =>
-      _internalLookUpConcreteGetter(getterName, library, false);
-
-  @override
-  MethodElement lookUpInheritedConcreteMethod(
-          String methodName, LibraryElement library) =>
-      _internalLookUpConcreteMethod(methodName, library, false);
-
-  @override
-  PropertyAccessorElement lookUpInheritedConcreteSetter(
-          String setterName, LibraryElement library) =>
-      _internalLookUpConcreteSetter(setterName, library, false);
-
-  @override
-  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) =>
-      _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);
-  }
-
-  void _collectAllSupertypes(List<InterfaceType> supertypes) {
-    List<InterfaceType> typesToVisit = new List<InterfaceType>();
-    List<ClassElement> visitedClasses = new List<ClassElement>();
-    typesToVisit.add(this.type);
-    while (!typesToVisit.isEmpty) {
-      InterfaceType currentType = typesToVisit.removeAt(0);
-      ClassElement currentElement = currentType.element;
-      if (!visitedClasses.contains(currentElement)) {
-        visitedClasses.add(currentElement);
-        if (!identical(currentType, this.type)) {
-          supertypes.add(currentType);
-        }
-        InterfaceType supertype = currentType.superclass;
-        if (supertype != null) {
-          typesToVisit.add(supertype);
-        }
-        for (InterfaceType type in currentElement.interfaces) {
-          typesToVisit.add(type);
-        }
-        for (InterfaceType type in currentElement.mixins) {
-          ClassElement element = type.element;
-          if (!visitedClasses.contains(element)) {
-            supertypes.add(type);
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Compute a list of constructors for this class, which is a mixin
-   * application.  If specified, [visitedClasses] is a list of the other mixin
-   * application classes which have been visited on the way to reaching this
-   * one (this is used to detect circularities).
-   */
-  List<ConstructorElement> _computeMixinAppConstructors(
-      [List<ClassElementImpl> visitedClasses = null]) {
-    // First get the list of constructors of the superclass which need to be
-    // forwarded to this class.
-    Iterable<ConstructorElement> constructorsToForward;
-    if (supertype == null) {
-      // Shouldn't ever happen, since the only class with no supertype is
-      // Object, and it isn't a mixin application.  But for safety's sake just
-      // assume an empty list.
-      assert(false);
-      constructorsToForward = <ConstructorElement>[];
-    } else if (!supertype.element.isMixinApplication) {
-      List<ConstructorElement> superclassConstructors =
-          supertype.element.constructors;
-      // Filter out any constructors with optional parameters (see
-      // dartbug.com/15101).
-      constructorsToForward =
-          superclassConstructors.where(isSuperConstructorAccessible);
-    } else {
-      if (visitedClasses == null) {
-        visitedClasses = <ClassElementImpl>[this];
-      } else {
-        if (visitedClasses.contains(this)) {
-          // Loop in the class hierarchy.  Don't try to forward any
-          // constructors.
-          return <ConstructorElement>[];
-        }
-        visitedClasses.add(this);
-      }
-      try {
-        ClassElementImpl superclass = supertype.element;
-        constructorsToForward =
-            superclass._computeMixinAppConstructors(visitedClasses);
-      } finally {
-        visitedClasses.removeLast();
-      }
-    }
-
-    // Figure out the type parameter substitution we need to perform in order
-    // to produce constructors for this class.  We want to be robust in the
-    // face of errors, so drop any extra type arguments and fill in any missing
-    // ones with `dynamic`.
-    List<DartType> parameterTypes =
-        TypeParameterTypeImpl.getTypes(supertype.typeParameters);
-    List<DartType> argumentTypes = new List<DartType>.filled(
-        parameterTypes.length, DynamicTypeImpl.instance);
-    for (int i = 0; i < supertype.typeArguments.length; i++) {
-      if (i >= argumentTypes.length) {
-        break;
-      }
-      argumentTypes[i] = supertype.typeArguments[i];
-    }
-
-    // Now create an implicit constructor for every constructor found above,
-    // substituting type parameters as appropriate.
-    return constructorsToForward
-        .map((ConstructorElement superclassConstructor) {
-      ConstructorElementImpl implicitConstructor =
-          new ConstructorElementImpl(superclassConstructor.name, -1);
-      implicitConstructor.synthetic = true;
-      implicitConstructor.redirectedConstructor = superclassConstructor;
-      implicitConstructor.const2 = superclassConstructor.isConst;
-      implicitConstructor.returnType = type;
-      List<ParameterElement> superParameters = superclassConstructor.parameters;
-      int count = superParameters.length;
-      if (count > 0) {
-        List<ParameterElement> implicitParameters =
-            new List<ParameterElement>(count);
-        for (int i = 0; i < count; i++) {
-          ParameterElement superParameter = superParameters[i];
-          ParameterElementImpl implicitParameter =
-              new ParameterElementImpl(superParameter.name, -1);
-          implicitParameter.const3 = superParameter.isConst;
-          implicitParameter.final2 = superParameter.isFinal;
-          implicitParameter.parameterKind = superParameter.parameterKind;
-          implicitParameter.synthetic = true;
-          implicitParameter.type =
-              superParameter.type.substitute2(argumentTypes, parameterTypes);
-          implicitParameters[i] = implicitParameter;
-        }
-        implicitConstructor.parameters = implicitParameters;
-      }
-      implicitConstructor.enclosingElement = this;
-      implicitConstructor.type = new FunctionTypeImpl(implicitConstructor);
-      return implicitConstructor;
-    }).toList();
-  }
-
-  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);
-    }
-    return getter;
-  }
-
-  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 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);
-    }
-    return setter;
-  }
-
-  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) {
-        ClassElement mixinElement = mixin.element;
-        if (mixinElement != null) {
-          PropertyAccessorElement element = mixinElement.getGetter(getterName);
-          if (element != null && element.isAccessibleIn(library)) {
-            return element;
-          }
-        }
-      }
-      InterfaceType supertype = currentElement.supertype;
-      if (supertype == null) {
-        return null;
-      }
-      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) {
-    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) {
-        ClassElement mixinElement = mixin.element;
-        if (mixinElement != null) {
-          MethodElement element = mixinElement.getMethod(methodName);
-          if (element != null && element.isAccessibleIn(library)) {
-            return element;
-          }
-        }
-      }
-      InterfaceType supertype = currentElement.supertype;
-      if (supertype == null) {
-        return null;
-      }
-      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) {
-    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) {
-        ClassElement mixinElement = mixin.element;
-        if (mixinElement != null) {
-          PropertyAccessorElement element = mixinElement.getSetter(setterName);
-          if (element != null && element.isAccessibleIn(library)) {
-            return element;
-          }
-        }
-      }
-      InterfaceType supertype = currentElement.supertype;
-      if (supertype == null) {
-        return null;
-      }
-      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) {
-    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;
-    }
-    List<InterfaceType> supertypes = classElt.interfaces;
-    for (int i = 0; i < supertypes.length; i++) {
-      if (_safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
-        return true;
-      }
-    }
-    supertypes = classElt.mixins;
-    for (int i = 0; i < supertypes.length; i++) {
-      if (_safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-/**
- * A concrete implementation of a [CompilationUnitElement].
- */
-class CompilationUnitElementImpl extends UriReferencedElementImpl
-    implements CompilationUnitElement {
-  /**
-   * The source that corresponds to this compilation unit.
-   */
-  Source source;
-
-  /**
-   * The source of the library containing this compilation unit.
-   *
-   * This is the same as the source of the containing [LibraryElement],
-   * except that it does not require the containing [LibraryElement] to be
-   * computed.
-   */
-  Source librarySource;
-
-  /**
-   * A list containing all of the top-level accessors (getters and setters)
-   * contained in this compilation unit.
-   */
-  List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the enums contained in this compilation unit.
-   */
-  List<ClassElement> _enums = ClassElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the top-level functions contained in this
-   * compilation unit.
-   */
-  List<FunctionElement> _functions = FunctionElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the function type aliases contained in this
-   * compilation unit.
-   */
-  List<FunctionTypeAliasElement> _typeAliases =
-      FunctionTypeAliasElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the types contained in this compilation unit.
-   */
-  List<ClassElement> _types = ClassElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the variables contained in this compilation unit.
-   */
-  List<TopLevelVariableElement> _variables = TopLevelVariableElement.EMPTY_LIST;
-
-  /**
-   * A map from offsets to elements of this unit at these offsets.
-   */
-  final Map<int, Element> _offsetToElementMap = new HashMap<int, Element>();
-
-  /**
-   * Initialize a newly created compilation unit element to have the given
-   * [name].
-   */
-  CompilationUnitElementImpl(String name) : super(name, -1);
-
-  @override
-  List<PropertyAccessorElement> get accessors => _accessors;
-
-  /**
-   * Set the top-level accessors (getters and setters) contained in this
-   * compilation unit to the given [accessors].
-   */
-  void set accessors(List<PropertyAccessorElement> accessors) {
-    for (PropertyAccessorElement accessor in accessors) {
-      (accessor as PropertyAccessorElementImpl).enclosingElement = this;
-    }
-    this._accessors = accessors;
-  }
-
-  @override
-  LibraryElement get enclosingElement =>
-      super.enclosingElement as LibraryElement;
-
-  @override
-  List<ClassElement> get enums => _enums;
-
-  /**
-   * Set the enums contained in this compilation unit to the given [enums].
-   */
-  void set enums(List<ClassElement> enums) {
-    for (ClassElement enumDeclaration in enums) {
-      (enumDeclaration as ClassElementImpl).enclosingElement = this;
-    }
-    this._enums = enums;
-  }
-
-  @override
-  List<FunctionElement> get functions => _functions;
-
-  /**
-   * Set the top-level functions contained in this compilation unit to the given
-   * [functions].
-   */
-  void set functions(List<FunctionElement> functions) {
-    for (FunctionElement function in functions) {
-      (function as FunctionElementImpl).enclosingElement = this;
-    }
-    this._functions = functions;
-  }
-
-  @override
-  List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
-
-  @override
-  int get hashCode => source.hashCode;
-
-  @override
-  bool get hasLoadLibraryFunction {
-    for (int i = 0; i < _functions.length; i++) {
-      if (_functions[i].name == FunctionElement.LOAD_LIBRARY_NAME) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  String get identifier => source.encoding;
-
-  @override
-  ElementKind get kind => ElementKind.COMPILATION_UNIT;
-
-  @override
-  List<TopLevelVariableElement> get topLevelVariables => _variables;
-
-  /**
-   * Set the top-level variables contained in this compilation unit to the given
-   * [variables].
-   */
-  void set topLevelVariables(List<TopLevelVariableElement> variables) {
-    for (TopLevelVariableElement field in variables) {
-      (field as TopLevelVariableElementImpl).enclosingElement = this;
-    }
-    this._variables = variables;
-  }
-
-  /**
-   * Set the function type aliases contained in this compilation unit to the
-   * given [typeAliases].
-   */
-  void set typeAliases(List<FunctionTypeAliasElement> typeAliases) {
-    for (FunctionTypeAliasElement typeAlias in typeAliases) {
-      (typeAlias as FunctionTypeAliasElementImpl).enclosingElement = this;
-    }
-    this._typeAliases = typeAliases;
-  }
-
-  @override
-  List<ClassElement> get types => _types;
-
-  /**
-   * Set the types contained in this compilation unit to the given [types].
-   */
-  void set types(List<ClassElement> types) {
-    for (ClassElement type in types) {
-      (type as ClassElementImpl).enclosingElement = this;
-    }
-    this._types = types;
-  }
-
-  @override
-  bool operator ==(Object object) =>
-      object is CompilationUnitElementImpl && source == object.source;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
-
-  /**
-   * This method is invoked after this unit was incrementally resolved.
-   */
-  void afterIncrementalResolution() {
-    _offsetToElementMap.clear();
-  }
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    if (source == null) {
-      buffer.write("{compilation unit}");
-    } else {
-      buffer.write(source.fullName);
-    }
-  }
-
-  @override
-  CompilationUnit computeNode() => unit;
-
-  @override
-  ElementImpl getChild(String identifier) {
-    //
-    // The casts in this method are safe because the set methods would have
-    // thrown a CCE if any of the elements in the arrays were not of the
-    // expected types.
-    //
-    for (PropertyAccessorElement accessor in _accessors) {
-      if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
-        return accessor as PropertyAccessorElementImpl;
-      }
-    }
-    for (VariableElement variable in _variables) {
-      if ((variable as VariableElementImpl).identifier == identifier) {
-        return variable as VariableElementImpl;
-      }
-    }
-    for (ExecutableElement function in _functions) {
-      if ((function as ExecutableElementImpl).identifier == identifier) {
-        return function as ExecutableElementImpl;
-      }
-    }
-    for (FunctionTypeAliasElement typeAlias in _typeAliases) {
-      if ((typeAlias as FunctionTypeAliasElementImpl).identifier ==
-          identifier) {
-        return typeAlias as FunctionTypeAliasElementImpl;
-      }
-    }
-    for (ClassElement type in _types) {
-      if ((type as ClassElementImpl).identifier == identifier) {
-        return type as ClassElementImpl;
-      }
-    }
-    for (ClassElement type in _enums) {
-      if ((type as ClassElementImpl).identifier == identifier) {
-        return type as ClassElementImpl;
-      }
-    }
-    return null;
-  }
-
-  @override
-  Element getElementAt(int offset) {
-    if (_offsetToElementMap.isEmpty) {
-      accept(new _BuildOffsetToElementMap(_offsetToElementMap));
-    }
-    return _offsetToElementMap[offset];
-  }
-
-  @override
-  ClassElement getEnum(String enumName) {
-    for (ClassElement enumDeclaration in _enums) {
-      if (enumDeclaration.name == enumName) {
-        return enumDeclaration;
-      }
-    }
-    return null;
-  }
-
-  @override
-  ClassElement getType(String className) {
-    for (ClassElement type in _types) {
-      if (type.name == className) {
-        return type;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Replace the given [from] top-level variable with [to] in this compilation unit.
-   */
-  void replaceTopLevelVariable(
-      TopLevelVariableElement from, TopLevelVariableElement to) {
-    int index = _variables.indexOf(from);
-    _variables[index] = to;
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChildren(_accessors, visitor);
-    safelyVisitChildren(_enums, visitor);
-    safelyVisitChildren(_functions, visitor);
-    safelyVisitChildren(_typeAliases, visitor);
-    safelyVisitChildren(_types, visitor);
-    safelyVisitChildren(_variables, visitor);
-  }
-}
-
-/**
- * A [FieldElement] for a 'const' or 'final' field that has an initializer.
- *
- * TODO(paulberry): we should rename this class to reflect the fact that it's
- * used for both const and final fields.  However, we shouldn't do so until
- * we've created an API for reading the values of constants; until that API is
- * available, clients are likely to read constant values by casting to
- * ConstFieldElementImpl, so it would be a breaking change to rename this
- * class.
- */
-class ConstFieldElementImpl extends FieldElementImpl with ConstVariableElement {
-  /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
-   * Initialize a newly created synthetic field element to have the given
-   * [name] and [offset].
-   */
-  ConstFieldElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created field element to have the given [name].
-   */
-  ConstFieldElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
-}
-
-/**
- * A [LocalVariableElement] for a local 'const' variable that has an
- * initializer.
- */
-class ConstLocalVariableElementImpl extends LocalVariableElementImpl
-    with ConstVariableElement {
-  /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
-   * Initialize a newly created local variable element to have the given [name]
-   * and [offset].
-   */
-  ConstLocalVariableElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created local variable element to have the given [name].
-   */
-  ConstLocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
-}
-
-/**
- * A concrete implementation of a [ConstructorElement].
- */
-class ConstructorElementImpl extends ExecutableElementImpl
-    implements ConstructorElement {
-  /**
-   * The constructor to which this constructor is redirecting.
-   */
-  ConstructorElement redirectedConstructor;
-
-  /**
-   * The initializers for this constructor (used for evaluating constant
-   * instance creation expressions).
-   */
-  List<ConstructorInitializer> constantInitializers;
-
-  /**
-   * The offset of the `.` before this constructor name or `null` if not named.
-   */
-  int periodOffset;
-
-  /**
-   * Return the offset of the character immediately following the last character
-   * of this constructor's name, or `null` if not named.
-   */
-  int nameEnd;
-
-  /**
-   * True if this constructor has been found by constant evaluation to be free
-   * of redirect cycles, and is thus safe to evaluate.
-   */
-  bool isCycleFree = false;
-
-  /**
-   * Initialize a newly created constructor element to have the given [name] and
-   * [offset].
-   */
-  ConstructorElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created constructor element to have the given [name].
-   */
-  ConstructorElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  /**
-   * Set whether this constructor represents a 'const' constructor.
-   */
-  void set const2(bool isConst) {
-    setModifier(Modifier.CONST, isConst);
-  }
-
-  @override
-  ClassElement get enclosingElement => super.enclosingElement as ClassElement;
-
-  /**
-   * Set whether this constructor represents a factory method.
-   */
-  void set factory(bool isFactory) {
-    setModifier(Modifier.FACTORY, isFactory);
-  }
-
-  @override
-  bool get isConst => hasModifier(Modifier.CONST);
-
-  @override
-  bool get isDefaultConstructor {
-    // unnamed
-    String name = this.name;
-    if (name != null && name.length != 0) {
-      return false;
-    }
-    // no required parameters
-    for (ParameterElement parameter in parameters) {
-      if (parameter.parameterKind == ParameterKind.REQUIRED) {
-        return false;
-      }
-    }
-    // OK, can be used as default constructor
-    return true;
-  }
-
-  @override
-  bool get isFactory => hasModifier(Modifier.FACTORY);
-
-  @override
-  bool get isStatic => false;
-
-  @override
-  ElementKind get kind => ElementKind.CONSTRUCTOR;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    if (enclosingElement == null) {
-      String message;
-      String name = displayName;
-      if (name != null && !name.isEmpty) {
-        message =
-            'Found constructor element named $name with no enclosing element';
-      } else {
-        message = 'Found unnamed constructor element with no enclosing element';
-      }
-      AnalysisEngine.instance.logger.logError(message);
-      buffer.write('<unknown class>');
-    } else {
-      buffer.write(enclosingElement.displayName);
-    }
-    String name = displayName;
-    if (name != null && !name.isEmpty) {
-      buffer.write(".");
-      buffer.write(name);
-    }
-    super.appendTo(buffer);
-  }
-
-  @override
-  ConstructorDeclaration computeNode() =>
-      getNodeMatching((node) => node is ConstructorDeclaration);
-}
-
-/**
- * A constructor element defined in a parameterized type where the values of the
- * type parameters are known.
- */
-class ConstructorMember extends ExecutableMember implements ConstructorElement {
-  /**
-   * Initialize a newly created element to represent a constructor, based on the
-   * [baseElement], defined by the [definingType]. If [type] is passed, it
-   * represents the full type of the member, and will take precedence over
-   * the [definingType].
-   */
-  ConstructorMember(ConstructorElement baseElement, InterfaceType definingType,
-      [FunctionType type])
-      : super(baseElement, definingType, type);
-
-  @override
-  ConstructorElement get baseElement => super.baseElement as ConstructorElement;
-
-  @override
-  InterfaceType get definingType => super.definingType as InterfaceType;
-
-  @override
-  ClassElement get enclosingElement => baseElement.enclosingElement;
-
-  @override
-  bool get isConst => baseElement.isConst;
-
-  @override
-  bool get isDefaultConstructor => baseElement.isDefaultConstructor;
-
-  @override
-  bool get isFactory => baseElement.isFactory;
-
-  @override
-  int get nameEnd => baseElement.nameEnd;
-
-  @override
-  int get periodOffset => baseElement.periodOffset;
-
-  @override
-  ConstructorElement get redirectedConstructor =>
-      from(baseElement.redirectedConstructor, definingType);
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
-
-  @override
-  ConstructorDeclaration computeNode() => baseElement.computeNode();
-
-  @override
-  String toString() {
-    ConstructorElement baseElement = this.baseElement;
-    List<ParameterElement> parameters = this.parameters;
-    FunctionType type = this.type;
-    StringBuffer buffer = new StringBuffer();
-    buffer.write(baseElement.enclosingElement.displayName);
-    String name = displayName;
-    if (name != null && !name.isEmpty) {
-      buffer.write(".");
-      buffer.write(name);
-    }
-    buffer.write("(");
-    int parameterCount = parameters.length;
-    for (int i = 0; i < parameterCount; i++) {
-      if (i > 0) {
-        buffer.write(", ");
-      }
-      buffer.write(parameters[i]);
-    }
-    buffer.write(")");
-    if (type != null) {
-      buffer.write(ElementImpl.RIGHT_ARROW);
-      buffer.write(type.returnType);
-    }
-    return buffer.toString();
-  }
-
-  /**
-   * 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 [definingType], create a constructor member representing
-   * the given constructor. Return the member that was created, or the original
-   * constructor if no member was created.
-   */
-  static ConstructorElement from(
-      ConstructorElement constructor, InterfaceType definingType) {
-    if (constructor == null || definingType.typeArguments.length == 0) {
-      return constructor;
-    }
-    FunctionType baseType = constructor.type;
-    if (baseType == null) {
-      // TODO(brianwilkerson) We need to understand when this can happen.
-      return constructor;
-    }
-    List<DartType> argumentTypes = definingType.typeArguments;
-    List<DartType> parameterTypes = definingType.element.type.typeArguments;
-    FunctionType substitutedType =
-        baseType.substitute2(argumentTypes, parameterTypes);
-    if (baseType == substitutedType) {
-      return constructor;
-    }
-    return new ConstructorMember(constructor, definingType, substitutedType);
-  }
-}
-
-/**
- * A [TopLevelVariableElement] for a top-level 'const' variable that has an
- * initializer.
- */
-class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl
-    with ConstVariableElement {
-  /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
-   * Initialize a newly created top-level variable element to have the given
-   * [name].
-   */
-  ConstTopLevelVariableElementImpl(Identifier name) : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
-}
-
-/**
- * Mixin used by elements that represent constant variables and have
- * initializers.
- *
- * Note that in correct Dart code, all constant variables must have
- * initializers.  However, analyzer also needs to handle incorrect Dart code,
- * in which case there might be some constant variables that lack initializers.
- * This interface is only used for constant variables that have initializers.
- *
- * This class is not intended to be part of the public API for analyzer.
- */
-abstract class ConstVariableElement {
-  /**
-   * If this element represents a constant variable, and it has an initializer,
-   * a copy of the initializer for the constant.  Otherwise `null`.
-   *
-   * Note that in correct Dart code, all constant variables must have
-   * initializers.  However, analyzer also needs to handle incorrect Dart code,
-   * in which case there might be some constant variables that lack
-   * initializers.
-   */
-  Expression constantInitializer;
-}
-
-/**
- * A [FieldFormalParameterElementImpl] for parameters that have an initializer.
- */
-class DefaultFieldFormalParameterElementImpl
-    extends FieldFormalParameterElementImpl with ConstVariableElement {
-  /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
-   * Initialize a newly created parameter element to have the given [name].
-   */
-  DefaultFieldFormalParameterElementImpl(Identifier name) : super(name);
-
-  @override
-  DartObject get constantValue => _result.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
-}
-
-/**
- * A [ParameterElement] for parameters that have an initializer.
- */
-class DefaultParameterElementImpl extends ParameterElementImpl
-    with ConstVariableElement {
-  /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
-   * Initialize a newly created parameter element to have the given [name].
-   */
-  DefaultParameterElementImpl(Identifier name) : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
-
-  @override
-  DefaultFormalParameter computeNode() =>
-      getNodeMatching((node) => node is DefaultFormalParameter);
-}
-
-/**
- * The synthetic element representing the declaration of the type `dynamic`.
- */
-class DynamicElementImpl extends ElementImpl implements TypeDefiningElement {
-  /**
-   * Return the unique instance of this class.
-   */
-  static DynamicElementImpl get instance =>
-      DynamicTypeImpl.instance.element as DynamicElementImpl;
-
-  @override
-  DynamicTypeImpl type;
-
-  /**
-   * Initialize a newly created instance of this class. Instances of this class
-   * should <b>not</b> be created except as part of creating the type associated
-   * with this element. The single instance of this class should be accessed
-   * through the method [getInstance].
-   */
-  DynamicElementImpl() : super(Keyword.DYNAMIC.syntax, -1) {
-    setModifier(Modifier.SYNTHETIC, true);
-  }
-
-  @override
-  ElementKind get kind => ElementKind.DYNAMIC;
-
-  @override
-  accept(ElementVisitor visitor) => null;
-}
-
-/**
- * The [Type] representing the type `dynamic`.
- */
-class DynamicTypeImpl extends TypeImpl {
-  /**
-   * The unique instance of this class.
-   */
-  static DynamicTypeImpl _INSTANCE = new DynamicTypeImpl._();
-
-  /**
-   * Return the unique instance of this class.
-   */
-  static DynamicTypeImpl get instance => _INSTANCE;
-
-  /**
-   * Prevent the creation of instances of this class.
-   */
-  DynamicTypeImpl._()
-      : super(new DynamicElementImpl(), Keyword.DYNAMIC.syntax) {
-    (element as DynamicElementImpl).type = this;
-  }
-
-  /**
-   * Constructor used by [CircularTypeImpl].
-   */
-  DynamicTypeImpl._circular()
-      : super(_INSTANCE.element, Keyword.DYNAMIC.syntax);
-
-  @override
-  int get hashCode => 1;
-
-  @override
-  bool get isDynamic => true;
-
-  @override
-  bool operator ==(Object object) => identical(object, this);
-
-  @override
-  bool isMoreSpecificThan(DartType type,
-      [bool withDynamic = false, Set<Element> visitedElements]) {
-    // T is S
-    if (identical(this, type)) {
-      return true;
-    }
-    // else
-    return withDynamic;
-  }
-
-  @override
-  bool isSubtypeOf(DartType type) => true;
-
-  @override
-  bool isSupertypeOf(DartType type) => true;
-
-  @override
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
-
-  @override
-  DartType substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) {
-    int length = parameterTypes.length;
-    for (int i = 0; i < length; i++) {
-      if (parameterTypes[i] == this) {
-        return argumentTypes[i];
-      }
-    }
-    return this;
-  }
-}
-
-/**
- * A concrete implementation of an [ElementAnnotation].
- */
-class ElementAnnotationImpl implements ElementAnnotation {
-  /**
-   * 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";
-
-  /**
-   * The name of the top-level variable used to mark a method as being expected
-   * to override an inherited method.
-   */
-  static String _OVERRIDE_VARIABLE_NAME = "override";
-
-  /**
-   * The name of the top-level variable used to mark a class as implementing a
-   * proxy object.
-   */
-  static String PROXY_VARIABLE_NAME = "proxy";
-
-  /**
-   * The element representing the field, variable, or constructor being used as
-   * an annotation.
-   */
-  final Element element;
-
-  /**
-   * The result of evaluating this annotation as a compile-time constant
-   * expression, or `null` if the compilation unit containing the variable has
-   * not been resolved.
-   */
-  EvaluationResultImpl evaluationResult;
-
-  /**
-   * Initialize a newly created annotation. The given [element] is the element
-   * representing the field, variable, or constructor being used as an
-   * annotation.
-   */
-  ElementAnnotationImpl(this.element);
-
-  @override
-  DartObject get constantValue => evaluationResult.value;
-
-  @override
-  bool get isDeprecated {
-    if (element != null) {
-      LibraryElement library = element.library;
-      if (library != null && library.isDartCore) {
-        if (element is ConstructorElement) {
-          ConstructorElement constructorElement = element as ConstructorElement;
-          if (constructorElement.enclosingElement.name ==
-              _DEPRECATED_CLASS_NAME) {
-            return true;
-          }
-        } else if (element is PropertyAccessorElement &&
-            element.name == _DEPRECATED_VARIABLE_NAME) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  @override
-  bool get isOverride {
-    if (element != null) {
-      LibraryElement library = element.library;
-      if (library != null && library.isDartCore) {
-        if (element is PropertyAccessorElement &&
-            element.name == _OVERRIDE_VARIABLE_NAME) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  @override
-  bool get isProxy {
-    if (element != null) {
-      LibraryElement library = element.library;
-      if (library != null && library.isDartCore) {
-        if (element is PropertyAccessorElement &&
-            element.name == PROXY_VARIABLE_NAME) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  @override
-  String toString() => '@$element';
-}
-
-/**
- * A base class for concrete implementations of an [Element].
- */
-abstract class ElementImpl implements Element {
-  /**
-   * An Unicode right arrow.
-   */
-  static final String RIGHT_ARROW = " \u2192 ";
-
-  static int _NEXT_ID = 0;
-
-  final int id = _NEXT_ID++;
-
-  /**
-   * The enclosing element of this element, or `null` if this element is at the
-   * root of the element structure.
-   */
-  ElementImpl _enclosingElement;
-
-  /**
-   * The name of this element.
-   */
-  String _name;
-
-  /**
-   * The offset of the name of this element in the file that contains the
-   * declaration of this element.
-   */
-  int _nameOffset = 0;
-
-  /**
-   * A bit-encoded form of the modifiers associated with this element.
-   */
-  int _modifiers = 0;
-
-  /**
-   * A list containing all of the metadata associated with this element.
-   */
-  List<ElementAnnotation> metadata = ElementAnnotation.EMPTY_LIST;
-
-  /**
-   * A cached copy of the calculated hashCode for this element.
-   */
-  int _cachedHashCode;
-
-  /**
-   * A cached copy of the calculated location for this element.
-   */
-  ElementLocation _cachedLocation;
-
-  /**
-   * The offset to the beginning of the documentation comment,
-   * or `null` if this element does not have a documentation comment.
-   */
-  int _docRangeOffset;
-
-  /**
-   * The length of the documentation comment range for this element.
-   */
-  int _docRangeLength;
-
-  /**
-   * Initialize a newly created element to have the given [name] at the given
-   * [_nameOffset].
-   */
-  ElementImpl(String name, this._nameOffset) {
-    this._name = StringUtilities.intern(name);
-  }
-
-  /**
-   * Initialize a newly created element to have the given [name].
-   */
-  ElementImpl.forNode(Identifier name)
-      : this(name == null ? "" : name.name, name == null ? -1 : name.offset);
-
-  @override
-  AnalysisContext get context {
-    if (_enclosingElement == null) {
-      return null;
-    }
-    return _enclosingElement.context;
-  }
-
-  @override
-  String get displayName => _name;
-
-  @override
-  SourceRange get docRange {
-    if (_docRangeOffset != null && _docRangeLength != null) {
-      return new SourceRange(_docRangeOffset, _docRangeLength);
-    }
-    return null;
-  }
-
-  @override
-  Element get enclosingElement => _enclosingElement;
-
-  /**
-   * Set the enclosing element of this element to the given [element].
-   */
-  void set enclosingElement(Element element) {
-    _enclosingElement = element as ElementImpl;
-    _cachedLocation = null;
-    _cachedHashCode = null;
-  }
-
-  @override
-  int get hashCode {
-    // TODO: We might want to re-visit this optimization in the future.
-    // We cache the hash code value as this is a very frequently called method.
-    if (_cachedHashCode == null) {
-      int hashIdentifier = identifier.hashCode;
-      Element enclosing = enclosingElement;
-      if (enclosing != null) {
-        _cachedHashCode = hashIdentifier + enclosing.hashCode;
-      } else {
-        _cachedHashCode = hashIdentifier;
-      }
-    }
-    return _cachedHashCode;
-  }
-
-  /**
-   * Return an identifier that uniquely identifies this element among the
-   * children of this element's parent.
-   */
-  String get identifier => name;
-
-  @override
-  bool get isDeprecated {
-    for (ElementAnnotation annotation in metadata) {
-      if (annotation.isDeprecated) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  bool get isOverride {
-    for (ElementAnnotation annotation in metadata) {
-      if (annotation.isOverride) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  bool get isPrivate {
-    String name = displayName;
-    if (name == null) {
-      return true;
-    }
-    return Identifier.isPrivateName(name);
-  }
-
-  @override
-  bool get isPublic => !isPrivate;
-
-  @override
-  bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
-
-  @override
-  LibraryElement get library =>
-      getAncestor((element) => element is LibraryElement);
-
-  @override
-  ElementLocation get location {
-    if (_cachedLocation == null) {
-      _cachedLocation = new ElementLocationImpl.con1(this);
-    }
-    return _cachedLocation;
-  }
-
-  @override
-  String get name => _name;
-
-  void set name(String name) {
-    this._name = name;
-    _cachedLocation = null;
-    _cachedHashCode = null;
-  }
-
-  @override
-  int get nameLength => displayName != null ? displayName.length : 0;
-
-  @override
-  int get nameOffset => _nameOffset;
-
-  /**
-   * Sets the offset of the name of this element in the file that contains the
-   * declaration of this element.
-   */
-  void set nameOffset(int offset) {
-    _nameOffset = offset;
-    _cachedHashCode = null;
-    _cachedLocation = null;
-  }
-
-  @override
-  Source get source {
-    if (_enclosingElement == null) {
-      return null;
-    }
-    return _enclosingElement.source;
-  }
-
-  /**
-   * Set whether this element is synthetic.
-   */
-  void set synthetic(bool isSynthetic) {
-    setModifier(Modifier.SYNTHETIC, isSynthetic);
-  }
-
-  @override
-  CompilationUnit get unit => context.resolveCompilationUnit(source, library);
-
-  @override
-  bool operator ==(Object object) {
-    if (identical(this, object)) {
-      return true;
-    }
-    if (object == null || hashCode != object.hashCode) {
-      return false;
-    }
-    return object.runtimeType == runtimeType &&
-        (object as Element).location == location;
-  }
-
-  /**
-   * Append a textual representation of this element to the given [buffer].
-   */
-  void appendTo(StringBuffer buffer) {
-    if (_name == null) {
-      buffer.write("<unnamed ");
-      buffer.write(runtimeType.toString());
-      buffer.write(">");
-    } else {
-      buffer.write(_name);
-    }
-  }
-
-  @override
-  String computeDocumentationComment() {
-    AnalysisContext context = this.context;
-    if (context == null) {
-      return null;
-    }
-    return context.computeDocumentationComment(this);
-  }
-
-  @override
-  AstNode computeNode() => getNodeMatching((node) => node is AstNode);
-
-  /**
-   * Set this element as the enclosing element for given [element].
-   */
-  void encloseElement(ElementImpl element) {
-    element.enclosingElement = this;
-  }
-
-  @override
-  Element getAncestor(Predicate<Element> predicate) {
-    Element ancestor = _enclosingElement;
-    while (ancestor != null && !predicate(ancestor)) {
-      ancestor = ancestor.enclosingElement;
-    }
-    return ancestor;
-  }
-
-  /**
-   * Return the child of this element that is uniquely identified by the given
-   * [identifier], or `null` if there is no such child.
-   */
-  ElementImpl getChild(String identifier) => null;
-
-  @override
-  String getExtendedDisplayName(String shortName) {
-    if (shortName == null) {
-      shortName = displayName;
-    }
-    Source source = this.source;
-    if (source != null) {
-      return "$shortName (${source.fullName})";
-    }
-    return shortName;
-  }
-
-  /**
-   * Return the resolved [AstNode] of the given type enclosing [getNameOffset].
-   */
-  AstNode getNodeMatching(Predicate<AstNode> predicate) {
-    CompilationUnit unit = this.unit;
-    if (unit == null) {
-      return null;
-    }
-    int offset = nameOffset;
-    AstNode node = new NodeLocator(offset).searchWithin(unit);
-    if (node == null) {
-      return null;
-    }
-    return node.getAncestor(predicate);
-  }
-
-  /**
-   * Return `true` if this element has the given [modifier] associated with it.
-   */
-  bool hasModifier(Modifier modifier) =>
-      BooleanArray.getEnum(_modifiers, modifier);
-
-  @override
-  bool isAccessibleIn(LibraryElement library) {
-    if (Identifier.isPrivateName(_name)) {
-      return library == this.library;
-    }
-    return true;
-  }
-
-  /**
-   * If the given [child] is not `null`, use the given [visitor] to visit it.
-   */
-  void safelyVisitChild(Element child, ElementVisitor visitor) {
-    if (child != null) {
-      child.accept(visitor);
-    }
-  }
-
-  /**
-   * Use the given [visitor] to visit all of the [children] in the given array.
-   */
-  void safelyVisitChildren(List<Element> children, ElementVisitor visitor) {
-    if (children != null) {
-      for (Element child in children) {
-        child.accept(visitor);
-      }
-    }
-  }
-
-  /**
-   * Set the documentation comment source range for this element.
-   */
-  void setDocRange(int offset, int length) {
-    _docRangeOffset = offset;
-    _docRangeLength = length;
-  }
-
-  /**
-   * Set whether the given [modifier] is associated with this element to
-   * correspond to the given [value].
-   */
-  void setModifier(Modifier modifier, bool value) {
-    _modifiers = BooleanArray.setEnum(_modifiers, modifier, value);
-  }
-
-  @override
-  String toString() {
-    StringBuffer buffer = new StringBuffer();
-    appendTo(buffer);
-    return buffer.toString();
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    // There are no children to visit
-  }
-}
-
-/**
- * A concrete implementation of an [ElementLocation].
- */
-class ElementLocationImpl implements ElementLocation {
-  /**
-   * The character used to separate components in the encoded form.
-   */
-  static int _SEPARATOR_CHAR = 0x3B;
-
-  /**
-   * The path to the element whose location is represented by this object.
-   */
-  List<String> _components;
-
-  /**
-   * The object managing [indexKeyId] and [indexLocationId].
-   */
-  Object indexOwner;
-
-  /**
-   * A cached id of this location in index.
-   */
-  int indexKeyId;
-
-  /**
-   * A cached id of this location in index.
-   */
-  int indexLocationId;
-
-  /**
-   * Initialize a newly created location to represent the given [element].
-   */
-  ElementLocationImpl.con1(Element element) {
-    List<String> components = new List<String>();
-    Element ancestor = element;
-    while (ancestor != null) {
-      components.insert(0, (ancestor as ElementImpl).identifier);
-      ancestor = ancestor.enclosingElement;
-    }
-    this._components = components;
-  }
-
-  /**
-   * Initialize a newly created location from the given [encoding].
-   */
-  ElementLocationImpl.con2(String encoding) {
-    this._components = _decode(encoding);
-  }
-
-  /**
-   * Initialize a newly created location from the given [components].
-   */
-  ElementLocationImpl.con3(List<String> components) {
-    this._components = components;
-  }
-
-  @override
-  List<String> get components => _components;
-
-  @override
-  String get encoding {
-    StringBuffer buffer = new StringBuffer();
-    int length = _components.length;
-    for (int i = 0; i < length; i++) {
-      if (i > 0) {
-        buffer.writeCharCode(_SEPARATOR_CHAR);
-      }
-      _encode(buffer, _components[i]);
-    }
-    return buffer.toString();
-  }
-
-  @override
-  int get hashCode {
-    int result = 1;
-    for (int i = 0; i < _components.length; i++) {
-      String component = _components[i];
-      result = 31 * result + component.hashCode;
-    }
-    return result;
-  }
-
-  @override
-  bool operator ==(Object object) {
-    if (identical(this, object)) {
-      return true;
-    }
-    if (object is! ElementLocationImpl) {
-      return false;
-    }
-    ElementLocationImpl location = object as ElementLocationImpl;
-    List<String> otherComponents = location._components;
-    int length = _components.length;
-    if (otherComponents.length != length) {
-      return false;
-    }
-    for (int i = 0; i < length; i++) {
-      if (_components[i] != otherComponents[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  @override
-  String toString() => encoding;
-
-  /**
-   * Decode the [encoding] of a location into a list of components and return
-   * the components.
-   */
-  List<String> _decode(String encoding) {
-    List<String> components = new List<String>();
-    StringBuffer buffer = new StringBuffer();
-    int index = 0;
-    int length = encoding.length;
-    while (index < length) {
-      int currentChar = encoding.codeUnitAt(index);
-      if (currentChar == _SEPARATOR_CHAR) {
-        if (index + 1 < length &&
-            encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
-          buffer.writeCharCode(_SEPARATOR_CHAR);
-          index += 2;
-        } else {
-          components.add(buffer.toString());
-          buffer = new StringBuffer();
-          index++;
-        }
-      } else {
-        buffer.writeCharCode(currentChar);
-        index++;
-      }
-    }
-    components.add(buffer.toString());
-    return components;
-  }
-
-  /**
-   * Append an encoded form of the given [component] to the given [buffer].
-   */
-  void _encode(StringBuffer buffer, String component) {
-    int length = component.length;
-    for (int i = 0; i < length; i++) {
-      int currentChar = component.codeUnitAt(i);
-      if (currentChar == _SEPARATOR_CHAR) {
-        buffer.writeCharCode(_SEPARATOR_CHAR);
-      }
-      buffer.writeCharCode(currentChar);
-    }
-  }
-}
-
-/**
- * A base class for concrete implementations of an [ExecutableElement].
- */
-abstract class ExecutableElementImpl extends ElementImpl
-    implements ExecutableElement {
-  /**
-   * A list containing all of the functions defined within this executable
-   * element.
-   */
-  List<FunctionElement> _functions = FunctionElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the labels defined within this executable element.
-   */
-  List<LabelElement> _labels = LabelElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the local variables defined within this executable
-   * element.
-   */
-  List<LocalVariableElement> _localVariables = LocalVariableElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the parameters defined by this executable element.
-   */
-  List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the type parameters defined for this executable
-   * element.
-   */
-  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
-
-  /**
-   * The return type defined by this executable element.
-   */
-  DartType returnType;
-
-  /**
-   * The type of function defined by this executable element.
-   */
-  FunctionType type;
-
-  /**
-   * Initialize a newly created executable element to have the given [name] and
-   * [offset].
-   */
-  ExecutableElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created executable element to have the given [name].
-   */
-  ExecutableElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  /**
-   * Set whether this executable element's body is asynchronous.
-   */
-  void set asynchronous(bool isAsynchronous) {
-    setModifier(Modifier.ASYNCHRONOUS, isAsynchronous);
-  }
-
-  /**
-   * Set whether this executable element is external.
-   */
-  void set external(bool isExternal) {
-    setModifier(Modifier.EXTERNAL, isExternal);
-  }
-
-  @override
-  List<FunctionElement> get functions => _functions;
-
-  /**
-   * Set the functions defined within this executable element to the given
-   * [functions].
-   */
-  void set functions(List<FunctionElement> functions) {
-    for (FunctionElement function in functions) {
-      (function as FunctionElementImpl).enclosingElement = this;
-    }
-    this._functions = functions;
-  }
-
-  /**
-   * Set whether this method's body is a generator.
-   */
-  void set generator(bool isGenerator) {
-    setModifier(Modifier.GENERATOR, isGenerator);
-  }
-
-  @override
-  bool get hasImplicitReturnType => hasModifier(Modifier.IMPLICIT_TYPE);
-
-  /**
-   * Set whether this executable element has an implicit return type.
-   */
-  void set hasImplicitReturnType(bool hasImplicitReturnType) {
-    setModifier(Modifier.IMPLICIT_TYPE, hasImplicitReturnType);
-  }
-
-  @override
-  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
-
-  @override
-  bool get isAsynchronous => hasModifier(Modifier.ASYNCHRONOUS);
-
-  @override
-  bool get isExternal => hasModifier(Modifier.EXTERNAL);
-
-  @override
-  bool get isGenerator => hasModifier(Modifier.GENERATOR);
-
-  @override
-  bool get isOperator => false;
-
-  @override
-  bool get isSynchronous => !hasModifier(Modifier.ASYNCHRONOUS);
-
-  @override
-  List<LabelElement> get labels => _labels;
-
-  /**
-   * Set the labels defined within this executable element to the given
-   * [labels].
-   */
-  void set labels(List<LabelElement> labels) {
-    for (LabelElement label in labels) {
-      (label as LabelElementImpl).enclosingElement = this;
-    }
-    this._labels = labels;
-  }
-
-  @override
-  List<LocalVariableElement> get localVariables => _localVariables;
-
-  /**
-   * Set the local variables defined within this executable element to the given
-   * [variables].
-   */
-  void set localVariables(List<LocalVariableElement> variables) {
-    for (LocalVariableElement variable in variables) {
-      (variable as LocalVariableElementImpl).enclosingElement = this;
-    }
-    this._localVariables = variables;
-  }
-
-  @override
-  List<ParameterElement> get parameters => _parameters;
-
-  /**
-   * Set the parameters defined by this executable element to the given
-   * [parameters].
-   */
-  void set parameters(List<ParameterElement> parameters) {
-    for (ParameterElement parameter in parameters) {
-      (parameter as ParameterElementImpl).enclosingElement = this;
-    }
-    this._parameters = parameters;
-  }
-
-  @override
-  List<TypeParameterElement> get typeParameters => _typeParameters;
-
-  /**
-   * Set the type parameters defined by this executable element to the given
-   * [typeParameters].
-   */
-  void set typeParameters(List<TypeParameterElement> typeParameters) {
-    for (TypeParameterElement parameter in typeParameters) {
-      (parameter as TypeParameterElementImpl).enclosingElement = this;
-    }
-    this._typeParameters = typeParameters;
-  }
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    if (this.kind != ElementKind.GETTER) {
-      int typeParameterCount = _typeParameters.length;
-      if (typeParameterCount > 0) {
-        buffer.write('<');
-        for (int i = 0; i < typeParameterCount; i++) {
-          if (i > 0) {
-            buffer.write(", ");
-          }
-          (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
-        }
-        buffer.write('>');
-      }
-      buffer.write("(");
-      String closing = null;
-      ParameterKind kind = ParameterKind.REQUIRED;
-      int parameterCount = _parameters.length;
-      for (int i = 0; i < parameterCount; i++) {
-        if (i > 0) {
-          buffer.write(", ");
-        }
-        ParameterElementImpl parameter = _parameters[i] as ParameterElementImpl;
-        ParameterKind parameterKind = parameter.parameterKind;
-        if (parameterKind != kind) {
-          if (closing != null) {
-            buffer.write(closing);
-          }
-          if (parameterKind == ParameterKind.POSITIONAL) {
-            buffer.write("[");
-            closing = "]";
-          } else if (parameterKind == ParameterKind.NAMED) {
-            buffer.write("{");
-            closing = "}";
-          } else {
-            closing = null;
-          }
-        }
-        kind = parameterKind;
-        parameter.appendToWithoutDelimiters(buffer);
-      }
-      if (closing != null) {
-        buffer.write(closing);
-      }
-      buffer.write(")");
-    }
-    if (type != null) {
-      buffer.write(ElementImpl.RIGHT_ARROW);
-      buffer.write(type.returnType);
-    }
-  }
-
-  @override
-  ElementImpl getChild(String identifier) {
-    for (ExecutableElement function in _functions) {
-      if ((function as ExecutableElementImpl).identifier == identifier) {
-        return function as ExecutableElementImpl;
-      }
-    }
-    for (LabelElement label in _labels) {
-      if ((label as LabelElementImpl).identifier == identifier) {
-        return label as LabelElementImpl;
-      }
-    }
-    for (VariableElement variable in _localVariables) {
-      if ((variable as VariableElementImpl).identifier == identifier) {
-        return variable as VariableElementImpl;
-      }
-    }
-    for (ParameterElement parameter in _parameters) {
-      if ((parameter as ParameterElementImpl).identifier == identifier) {
-        return parameter as ParameterElementImpl;
-      }
-    }
-    return null;
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChildren(_functions, visitor);
-    safelyVisitChildren(_labels, visitor);
-    safelyVisitChildren(_localVariables, visitor);
-    safelyVisitChildren(_parameters, visitor);
-  }
-}
-
-/**
- * An executable element defined in a parameterized type where the values of the
- * type parameters are known.
- */
-abstract class ExecutableMember extends Member implements ExecutableElement {
-  @override
-  final FunctionType type;
-
-  /**
-   * Initialize a newly created element to represent a callable element (like a
-   * method or function or property), based on the [baseElement], defined by the
-   * [definingType]. If [type] is passed, it represents the full type of the
-   * member, and will take precedence over the [definingType].
-   */
-  ExecutableMember(ExecutableElement baseElement, InterfaceType definingType,
-      [FunctionType type])
-      : type = type ??
-            baseElement.type.substitute2(definingType.typeArguments,
-                TypeParameterTypeImpl.getTypes(definingType.typeParameters)),
-        super(baseElement, definingType);
-
-  @override
-  ExecutableElement get baseElement => super.baseElement as ExecutableElement;
-
-  @override
-  List<FunctionElement> get functions {
-    //
-    // Elements within this element should have type parameters substituted,
-    // just like this element.
-    //
-    throw new UnsupportedOperationException();
-//    return getBaseElement().getFunctions();
-  }
-
-  @override
-  bool get hasImplicitReturnType => baseElement.hasImplicitReturnType;
-
-  @override
-  bool get isAbstract => baseElement.isAbstract;
-
-  @override
-  bool get isAsynchronous => baseElement.isAsynchronous;
-
-  @override
-  bool get isExternal => baseElement.isExternal;
-
-  @override
-  bool get isGenerator => baseElement.isGenerator;
-
-  @override
-  bool get isOperator => baseElement.isOperator;
-
-  @override
-  bool get isStatic => baseElement.isStatic;
-
-  @override
-  bool get isSynchronous => baseElement.isSynchronous;
-
-  @override
-  List<LabelElement> get labels => baseElement.labels;
-
-  @override
-  List<LocalVariableElement> get localVariables {
-    //
-    // Elements within this element should have type parameters substituted,
-    // just like this element.
-    //
-    throw new UnsupportedOperationException();
-//    return getBaseElement().getLocalVariables();
-  }
-
-  @override
-  List<ParameterElement> get parameters => type.parameters;
-
-  @override
-  DartType get returnType => type.returnType;
-
-  @override
-  List<TypeParameterElement> get typeParameters => baseElement.typeParameters;
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    // TODO(brianwilkerson) We need to finish implementing the accessors used
-    // below so that we can safely invoke them.
-    super.visitChildren(visitor);
-    safelyVisitChildren(baseElement.functions, visitor);
-    safelyVisitChildren(labels, visitor);
-    safelyVisitChildren(baseElement.localVariables, visitor);
-    safelyVisitChildren(parameters, visitor);
-  }
-}
-
-/**
- * A concrete implementation of an [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_LIST;
-
-  /**
-   * Initialize a newly created export element at the given [offset].
-   */
-  ExportElementImpl(int offset) : super(null, offset);
-
-  @override
-  String get identifier => exportedLibrary.name;
-
-  @override
-  ElementKind get kind => ElementKind.EXPORT;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitExportElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write("export ");
-    (exportedLibrary as LibraryElementImpl).appendTo(buffer);
-  }
-}
-
-/**
- * A concrete implementation of a [FieldElement].
- */
-class FieldElementImpl extends PropertyInducingElementImpl
-    implements FieldElement {
-  /**
-   * Initialize a newly created synthetic field element to have the given [name]
-   * at the given [offset].
-   */
-  FieldElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created field element to have the given [name].
-   */
-  FieldElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  ClassElement get enclosingElement => super.enclosingElement as ClassElement;
-
-  @override
-  bool get isEnumConstant =>
-      enclosingElement != null ? enclosingElement.isEnum : false;
-
-  @override
-  ElementKind get kind => ElementKind.FIELD;
-
-  /**
-   * Set whether this field is static.
-   */
-  void set static(bool isStatic) {
-    setModifier(Modifier.STATIC, isStatic);
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
-
-  @override
-  AstNode computeNode() {
-    if (isEnumConstant) {
-      return getNodeMatching((node) => node is EnumConstantDeclaration);
-    } else {
-      return getNodeMatching((node) => node is VariableDeclaration);
-    }
-  }
-}
-
-/**
- * A [ParameterElementImpl] that has the additional information of the
- * [FieldElement] associated with the parameter.
- */
-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].
-   */
-  FieldFormalParameterElementImpl(Identifier name) : super.forNode(name);
-
-  @override
-  bool get isInitializingFormal => true;
-
-  @override
-  accept(ElementVisitor visitor) =>
-      visitor.visitFieldFormalParameterElement(this);
-}
-
-/**
- * A parameter element defined in a parameterized type where the values of the
- * type parameters are known.
- */
-class FieldFormalParameterMember extends ParameterMember
-    implements FieldFormalParameterElement {
-  /**
-   * Initialize a newly created element to represent a field formal parameter,
-   * based on the [baseElement], defined by the [definingType]. If [type]
-   * is passed it will be used as the substituted type for this member.
-   */
-  FieldFormalParameterMember(
-      FieldFormalParameterElement baseElement, ParameterizedType definingType,
-      [DartType type])
-      : super(baseElement, definingType, type);
-
-  @override
-  FieldElement get field {
-    FieldElement field = (baseElement as FieldFormalParameterElement).field;
-    if (field is FieldElement) {
-      return FieldMember.from(
-          field, substituteFor(field.enclosingElement.type));
-    }
-    return field;
-  }
-
-  @override
-  accept(ElementVisitor visitor) =>
-      visitor.visitFieldFormalParameterElement(this);
-}
-
-/**
- * A field element defined in a parameterized type where the values of the type
- * parameters are known.
- */
-class FieldMember extends VariableMember implements FieldElement {
-  /**
-   * Initialize a newly created element to represent a field, based on the
-   * [baseElement], defined by the [definingType].
-   */
-  FieldMember(FieldElement baseElement, InterfaceType definingType)
-      : super(baseElement, definingType);
-
-  @override
-  FieldElement get baseElement => super.baseElement as FieldElement;
-
-  @override
-  ClassElement get enclosingElement => baseElement.enclosingElement;
-
-  @override
-  PropertyAccessorElement get getter =>
-      PropertyAccessorMember.from(baseElement.getter, definingType);
-
-  @override
-  bool get isEnumConstant => baseElement.isEnumConstant;
-
-  @override
-  DartType get propagatedType => substituteFor(baseElement.propagatedType);
-
-  @override
-  PropertyAccessorElement get setter =>
-      PropertyAccessorMember.from(baseElement.setter, definingType);
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
-
-  @override
-  VariableDeclaration computeNode() => baseElement.computeNode();
-
-  @override
-  String toString() => '$type $displayName';
-
-  /**
-   * If the given [field]'s type is different when any type parameters from the
-   * defining type's declaration are replaced with the actual type arguments
-   * from the [definingType], create a field member representing the given
-   * field. Return the member that was created, or the base field if no member
-   * was created.
-   */
-  static FieldElement from(FieldElement field, ParameterizedType definingType) {
-    if (!_isChangedByTypeSubstitution(field, definingType)) {
-      return field;
-    }
-    // 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 FieldMember(field, definingType);
-  }
-
-  /**
-   * Determine whether the given [field]'s type is changed when type parameters
-   * from the [definingType]'s declaration are replaced with the actual type
-   * arguments from the defining type.
-   */
-  static bool _isChangedByTypeSubstitution(
-      FieldElement field, ParameterizedType definingType) {
-    List<DartType> argumentTypes = definingType.typeArguments;
-    if (field != null && argumentTypes.length != 0) {
-      DartType baseType = field.type;
-      List<DartType> parameterTypes =
-          TypeParameterTypeImpl.getTypes(definingType.typeParameters);
-      if (baseType != null) {
-        DartType substitutedType =
-            baseType.substitute2(argumentTypes, parameterTypes);
-        if (baseType != substitutedType) {
-          return true;
-        }
-      }
-      // If the field has a propagated type, then we need to check whether the
-      // propagated type needs substitution.
-      DartType basePropagatedType = field.propagatedType;
-      if (basePropagatedType != null) {
-        DartType substitutedPropagatedType =
-            basePropagatedType.substitute2(argumentTypes, parameterTypes);
-        if (basePropagatedType != substitutedPropagatedType) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-}
-
-/**
- * A concrete implementation of a [FunctionElement].
- */
-class FunctionElementImpl extends ExecutableElementImpl
-    implements FunctionElement {
-  /**
-   * 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.
-   */
-  int _visibleRangeLength = -1;
-
-  /**
-   * Initialize a newly created function element to have the given [name] and
-   * [offset].
-   */
-  FunctionElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created function element to have the given [name].
-   */
-  FunctionElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  /**
-   * Initialize a newly created function element to have no name and the given
-   * [offset]. This is used for function expressions, that have no name.
-   */
-  FunctionElementImpl.forOffset(int nameOffset) : super("", nameOffset);
-
-  @override
-  String get identifier {
-    String identifier = super.identifier;
-    if (!isStatic) {
-      identifier += "@$nameOffset";
-    }
-    return identifier;
-  }
-
-  @override
-  bool get isEntryPoint {
-    return isStatic && displayName == FunctionElement.MAIN_FUNCTION_NAME;
-  }
-
-  @override
-  bool get isStatic => enclosingElement is CompilationUnitElement;
-
-  @override
-  ElementKind get kind => ElementKind.FUNCTION;
-
-  @override
-  SourceRange get visibleRange {
-    if (_visibleRangeLength < 0) {
-      return null;
-    }
-    return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    String name = displayName;
-    if (name != null) {
-      buffer.write(name);
-    }
-    super.appendTo(buffer);
-  }
-
-  @override
-  FunctionDeclaration computeNode() =>
-      getNodeMatching((node) => node is FunctionDeclaration);
-
-  /**
-   * Set the visible range for this element to the range starting at the given
-   * [offset] with the given [length].
-   */
-  void setVisibleRange(int offset, int length) {
-    _visibleRangeOffset = offset;
-    _visibleRangeLength = length;
-  }
-
-  /**
-   * Set the parameters defined by this type alias to the given [parameters]
-   * without becoming the parent of the parameters. This should only be used by
-   * the [TypeResolverVisitor] when creating a synthetic type alias.
-   */
-  void shareParameters(List<ParameterElement> parameters) {
-    this._parameters = parameters;
-  }
-}
-
-/**
- * An element of a generic function, where the type parameters are known.
- */
-// TODO(jmesserly): the term "function member" is a bit weird, but it allows
-// a certain consistency.
-class FunctionMember extends ExecutableMember implements FunctionElement {
-  /**
-   * Initialize a newly created element to represent a function, based on the
-   * [baseElement], with the corresponding function [type].
-   */
-  FunctionMember(FunctionElement baseElement, [DartType type])
-      : super(baseElement, null, type);
-
-  @override
-  FunctionElement get baseElement => super.baseElement as FunctionElement;
-
-  @override
-  Element get enclosingElement => baseElement.enclosingElement;
-
-  @override
-  bool get isEntryPoint => baseElement.isEntryPoint;
-
-  @override
-  SourceRange get visibleRange => baseElement.visibleRange;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
-
-  @override
-  FunctionDeclaration computeNode() => baseElement.computeNode();
-
-  @override
-  String toString() {
-    StringBuffer buffer = new StringBuffer();
-    buffer.write(baseElement.displayName);
-    (type as FunctionTypeImpl).appendTo(buffer);
-    return buffer.toString();
-  }
-
-  /**
-   * 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 [definingType], create a method member representing the given
-   * method. Return the member that was created, or the base method if no member
-   * was created.
-   */
-  static MethodElement from(
-      MethodElement method, ParameterizedType definingType) {
-    if (method == null || definingType.typeArguments.length == 0) {
-      return method;
-    }
-    FunctionType baseType = method.type;
-    List<DartType> argumentTypes = definingType.typeArguments;
-    List<DartType> parameterTypes =
-        TypeParameterTypeImpl.getTypes(definingType.typeParameters);
-    FunctionType substitutedType =
-        baseType.substitute2(argumentTypes, parameterTypes);
-    if (baseType == substitutedType) {
-      return method;
-    }
-    return new MethodMember(method, definingType, substitutedType);
-  }
-}
-
-/**
- * A concrete implementation of a [FunctionTypeAliasElement].
- */
-class FunctionTypeAliasElementImpl extends ElementImpl
-    implements FunctionTypeAliasElement {
-  /**
-   * A list containing all of the parameters defined by this type alias.
-   */
-  List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
-
-  /**
-   * The return type defined by this type alias.
-   */
-  DartType returnType;
-
-  /**
-   * The type of function defined by this type alias.
-   */
-  FunctionType type;
-
-  /**
-   * A list containing all of the type parameters defined for this type.
-   */
-  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
-
-  /**
-   * Initialize a newly created type alias element to have the given name.
-   *
-   * [name] the name of this element
-   * [nameOffset] the offset of the name of this element in the file that
-   *    contains the declaration of this element
-   */
-  FunctionTypeAliasElementImpl(String name, int nameOffset)
-      : super(name, nameOffset);
-
-  /**
-   * Initialize a newly created type alias element to have the given [name].
-   */
-  FunctionTypeAliasElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  CompilationUnitElement get enclosingElement =>
-      super.enclosingElement as CompilationUnitElement;
-
-  @override
-  ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
-
-  @override
-  List<ParameterElement> get parameters => _parameters;
-
-  /**
-   * Set the parameters defined by this type alias to the given [parameters].
-   */
-  void set parameters(List<ParameterElement> parameters) {
-    if (parameters != null) {
-      for (ParameterElement parameter in parameters) {
-        (parameter as ParameterElementImpl).enclosingElement = this;
-      }
-    }
-    this._parameters = parameters;
-  }
-
-  @override
-  List<TypeParameterElement> get typeParameters => _typeParameters;
-
-  /**
-   * Set the type parameters defined for this type to the given
-   * [typeParameters].
-   */
-  void set typeParameters(List<TypeParameterElement> typeParameters) {
-    for (TypeParameterElement typeParameter in typeParameters) {
-      (typeParameter as TypeParameterElementImpl).enclosingElement = this;
-    }
-    this._typeParameters = typeParameters;
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitFunctionTypeAliasElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write("typedef ");
-    buffer.write(displayName);
-    int typeParameterCount = _typeParameters.length;
-    if (typeParameterCount > 0) {
-      buffer.write("<");
-      for (int i = 0; i < typeParameterCount; i++) {
-        if (i > 0) {
-          buffer.write(", ");
-        }
-        (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
-      }
-      buffer.write(">");
-    }
-    buffer.write("(");
-    int parameterCount = _parameters.length;
-    for (int i = 0; i < parameterCount; i++) {
-      if (i > 0) {
-        buffer.write(", ");
-      }
-      (_parameters[i] as ParameterElementImpl).appendTo(buffer);
-    }
-    buffer.write(")");
-    if (type != null) {
-      buffer.write(ElementImpl.RIGHT_ARROW);
-      buffer.write(type.returnType);
-    } else if (returnType != null) {
-      buffer.write(ElementImpl.RIGHT_ARROW);
-      buffer.write(returnType);
-    }
-  }
-
-  @override
-  FunctionTypeAlias computeNode() =>
-      getNodeMatching((node) => node is FunctionTypeAlias);
-
-  @override
-  ElementImpl getChild(String identifier) {
-    for (VariableElement parameter in _parameters) {
-      if ((parameter as VariableElementImpl).identifier == identifier) {
-        return parameter as VariableElementImpl;
-      }
-    }
-    for (TypeParameterElement typeParameter in _typeParameters) {
-      if ((typeParameter as TypeParameterElementImpl).identifier ==
-          identifier) {
-        return typeParameter as TypeParameterElementImpl;
-      }
-    }
-    return null;
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChildren(_parameters, visitor);
-    safelyVisitChildren(_typeParameters, visitor);
-  }
-}
-
-/**
- * The type of a function, method, constructor, getter, or setter.
- */
-class FunctionTypeImpl extends TypeImpl implements FunctionType {
-  /**
-   * The list of [typeArguments].
-   */
-  List<DartType> _typeArguments;
-
-  /**
-   * The list of [typeParameters].
-   */
-  List<TypeParameterElement> _typeParameters;
-
-  /**
-   * The list of [boundTypeParameters].
-   */
-  List<TypeParameterElement> _boundTypeParameters;
-
-  /**
-   * The set of typedefs which should not be expanded when exploring this type,
-   * to avoid creating infinite types in response to self-referential typedefs.
-   */
-  final List<FunctionTypeAliasElement> prunedTypedefs;
-
-  /**
-   * Initialize a newly created function type to be declared by the given
-   * [element], and also initialize [typeArguments] to match the
-   * [typeParameters], which permits later substitution.
-   */
-  FunctionTypeImpl(ExecutableElement element,
-      [List<FunctionTypeAliasElement> prunedTypedefs])
-      : this._(element, null, prunedTypedefs, null, null, null);
-
-  /**
-   * Initialize a newly created function type to be declared by the given
-   * [element].
-   */
-  FunctionTypeImpl.forTypedef(FunctionTypeAliasElement element,
-      [List<FunctionTypeAliasElement> prunedTypedefs])
-      : this._(element, element?.name, prunedTypedefs, null, null, null);
-
-  /**
-   * Private constructor.
-   */
-  FunctionTypeImpl._(
-      TypeParameterizedElement element,
-      String name,
-      this.prunedTypedefs,
-      List<DartType> typeArguments,
-      List<TypeParameterElement> typeParameters,
-      List<TypeParameterElement> boundTypeParameters)
-      : super(element, name) {
-    _boundTypeParameters = boundTypeParameters ??
-        element?.typeParameters ??
-        TypeParameterElement.EMPTY_LIST;
-
-    if (typeParameters == null) {
-      // Combine the generic type variables from all enclosing contexts, except
-      // for this generic function's type variables. Those variables are
-      // tracked in [boundTypeParameters].
-      typeParameters = <TypeParameterElement>[];
-      Element e = element?.enclosingElement;
-      while (e != null) {
-        if (e is TypeParameterizedElement) {
-          typeParameters.addAll((e as TypeParameterizedElement).typeParameters);
-        }
-        e = e.enclosingElement;
-      }
-    }
-    _typeParameters = typeParameters;
-
-    if (typeArguments == null) {
-      // TODO(jmesserly): reuse TypeParameterTypeImpl.getTypes once we can
-      // make it generic, which will allow it to return List<DartType> instead
-      // of List<TypeParameterType>.
-      if (typeParameters.isEmpty) {
-        typeArguments = DartType.EMPTY_LIST;
-      } else {
-        typeArguments = new List<DartType>.from(
-            typeParameters.map((t) => t.type),
-            growable: false);
-      }
-    }
-    _typeArguments = typeArguments;
-  }
-
-  /**
-   * Return the base parameter elements of this function element.
-   */
-  List<ParameterElement> get baseParameters => element.parameters;
-
-  /**
-   * Return the return type defined by this function's element.
-   */
-  DartType get baseReturnType => element.returnType;
-
-  @override
-  List<TypeParameterElement> get boundTypeParameters => _boundTypeParameters;
-
-  @override
-  String get displayName {
-    String name = this.name;
-    if (name == null || name.length == 0) {
-      // Function types have an empty name when they are defined implicitly by
-      // either a closure or as part of a parameter declaration.
-      List<DartType> normalParameterTypes = this.normalParameterTypes;
-      List<DartType> optionalParameterTypes = this.optionalParameterTypes;
-      Map<String, DartType> namedParameterTypes = this.namedParameterTypes;
-      DartType returnType = this.returnType;
-      StringBuffer buffer = new StringBuffer();
-      buffer.write("(");
-      bool needsComma = false;
-      if (normalParameterTypes.length > 0) {
-        for (DartType type in normalParameterTypes) {
-          if (needsComma) {
-            buffer.write(", ");
-          } else {
-            needsComma = true;
-          }
-          buffer.write(type.displayName);
-        }
-      }
-      if (optionalParameterTypes.length > 0) {
-        if (needsComma) {
-          buffer.write(", ");
-          needsComma = false;
-        }
-        buffer.write("[");
-        for (DartType type in optionalParameterTypes) {
-          if (needsComma) {
-            buffer.write(", ");
-          } else {
-            needsComma = true;
-          }
-          buffer.write(type.displayName);
-        }
-        buffer.write("]");
-        needsComma = true;
-      }
-      if (namedParameterTypes.length > 0) {
-        if (needsComma) {
-          buffer.write(", ");
-          needsComma = false;
-        }
-        buffer.write("{");
-        namedParameterTypes.forEach((String name, DartType type) {
-          if (needsComma) {
-            buffer.write(", ");
-          } else {
-            needsComma = true;
-          }
-          buffer.write(name);
-          buffer.write(": ");
-          buffer.write(type.displayName);
-        });
-        buffer.write("}");
-        needsComma = true;
-      }
-      buffer.write(")");
-      buffer.write(ElementImpl.RIGHT_ARROW);
-      if (returnType == null) {
-        buffer.write("null");
-      } else {
-        buffer.write(returnType.displayName);
-      }
-      name = buffer.toString();
-    }
-    return name;
-  }
-
-  @override
-  FunctionTypedElement get element => super.element;
-
-  @override
-  int get hashCode {
-    if (element == null) {
-      return 0;
-    }
-    // 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).hashCode;
-    for (int i = 0; i < normalParameterTypes.length; i++) {
-      code = (code << 1) + (normalParameterTypes[i] as TypeImpl).hashCode;
-    }
-    for (int i = 0; i < optionalParameterTypes.length; i++) {
-      code = (code << 1) + (optionalParameterTypes[i] as TypeImpl).hashCode;
-    }
-    for (DartType type in namedParameterTypes) {
-      code = (code << 1) + (type as TypeImpl).hashCode;
-    }
-    return code;
-  }
-
-  /**
-   * The type arguments that were used to instantiate this function type, if
-   * any, otherwise this will return an empty list.
-   *
-   * Given a function type `f`:
-   *
-   *     f == f.originalFunction.instantiate(f.instantiatedTypeArguments)
-   *
-   * Will always hold.
-   */
-  List<DartType> get instantiatedTypeArguments {
-    int typeParameterCount = element.type.boundTypeParameters.length;
-    if (typeParameterCount == 0) {
-      return DartType.EMPTY_LIST;
-    }
-    // The substituted types at the end should be our bound type parameters.
-    int skipCount = typeArguments.length - typeParameterCount;
-    return new List<DartType>.from(typeArguments.skip(skipCount));
-  }
-
-  @override
-  Map<String, DartType> get namedParameterTypes {
-    LinkedHashMap<String, DartType> namedParameterTypes =
-        new LinkedHashMap<String, DartType>();
-    List<ParameterElement> parameters = baseParameters;
-    if (parameters.length == 0) {
-      return namedParameterTypes;
-    }
-    List<DartType> typeParameters =
-        TypeParameterTypeImpl.getTypes(this.typeParameters);
-    for (ParameterElement parameter in parameters) {
-      if (parameter.parameterKind == ParameterKind.NAMED) {
-        DartType type = parameter.type;
-        if (typeArguments.length != 0 &&
-            typeArguments.length == typeParameters.length) {
-          type = (type as TypeImpl)
-              .substitute2(typeArguments, typeParameters, newPrune);
-        } else {
-          type = (type as TypeImpl).pruned(newPrune);
-        }
-        namedParameterTypes[parameter.name] = type;
-      }
-    }
-    return namedParameterTypes;
-  }
-
-  /**
-   * Determine the new set of typedefs which should be pruned when expanding
-   * this function type.
-   */
-  List<FunctionTypeAliasElement> get newPrune {
-    Element element = this.element;
-    if (element is FunctionTypeAliasElement && !element.isSynthetic) {
-      // This typedef should be pruned, along with anything that was previously
-      // pruned.
-      if (prunedTypedefs == null) {
-        return <FunctionTypeAliasElement>[element];
-      } else {
-        return new List<FunctionTypeAliasElement>.from(prunedTypedefs)
-          ..add(element);
-      }
-    } else {
-      // This is not a typedef, so nothing additional needs to be pruned.
-      return prunedTypedefs;
-    }
-  }
-
-  @override
-  List<DartType> get normalParameterTypes {
-    List<ParameterElement> parameters = baseParameters;
-    if (parameters.length == 0) {
-      return DartType.EMPTY_LIST;
-    }
-    List<DartType> typeParameters =
-        TypeParameterTypeImpl.getTypes(this.typeParameters);
-    List<DartType> types = new List<DartType>();
-    for (ParameterElement parameter in parameters) {
-      if (parameter.parameterKind == ParameterKind.REQUIRED) {
-        DartType type = parameter.type;
-        if (typeArguments.length != 0 &&
-            typeArguments.length == typeParameters.length) {
-          type = (type as TypeImpl)
-              .substitute2(typeArguments, typeParameters, newPrune);
-        } else {
-          type = (type as TypeImpl).pruned(newPrune);
-        }
-        types.add(type);
-      }
-    }
-    return types;
-  }
-
-  @override
-  List<DartType> get optionalParameterTypes {
-    List<ParameterElement> parameters = baseParameters;
-    if (parameters.length == 0) {
-      return DartType.EMPTY_LIST;
-    }
-    List<DartType> typeParameters =
-        TypeParameterTypeImpl.getTypes(this.typeParameters);
-    List<DartType> types = new List<DartType>();
-    for (ParameterElement parameter in parameters) {
-      if (parameter.parameterKind == ParameterKind.POSITIONAL) {
-        DartType type = parameter.type;
-        if (typeArguments.length != 0 &&
-            typeArguments.length == typeParameters.length) {
-          type = (type as TypeImpl)
-              .substitute2(typeArguments, typeParameters, newPrune);
-        } else {
-          type = (type as TypeImpl).pruned(newPrune);
-        }
-        types.add(type);
-      }
-    }
-    return types;
-  }
-
-  /**
-   * If this is an instantiation of a generic function type, this will get
-   * the original function from which it was instantiated.
-   *
-   * Otherwise, this will return `this`.
-   */
-  FunctionTypeImpl get originalFunction {
-    if (element.type.boundTypeParameters.isEmpty) {
-      return this;
-    }
-    return (element.type as FunctionTypeImpl).substitute2(typeArguments,
-        TypeParameterTypeImpl.getTypes(typeParameters), prunedTypedefs);
-  }
-
-  @override
-  List<ParameterElement> get parameters {
-    List<ParameterElement> baseParameters = this.baseParameters;
-    // no parameters, quick return
-    int parameterCount = baseParameters.length;
-    if (parameterCount == 0) {
-      return baseParameters;
-    }
-    // create specialized parameters
-    List<ParameterElement> specializedParameters =
-        new List<ParameterElement>(parameterCount);
-    for (int i = 0; i < parameterCount; i++) {
-      specializedParameters[i] = ParameterMember.from(baseParameters[i], this);
-    }
-    return specializedParameters;
-  }
-
-  @override
-  DartType get returnType {
-    DartType baseReturnType = this.baseReturnType;
-    if (baseReturnType == null) {
-      // TODO(brianwilkerson) This is a patch. The return type should never be
-      // 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 as TypeImpl).pruned(newPrune);
-    }
-    return (baseReturnType as TypeImpl).substitute2(typeArguments,
-        TypeParameterTypeImpl.getTypes(typeParameters), newPrune);
-  }
-
-  /**
-   * A list containing the actual types of the type arguments.
-   */
-  List<DartType> get typeArguments => _typeArguments;
-
-  @override
-  List<TypeParameterElement> get typeParameters => _typeParameters;
-
-  @override
-  bool operator ==(Object object) {
-    if (object is! FunctionTypeImpl) {
-      return false;
-    }
-    FunctionTypeImpl otherType = object as FunctionTypeImpl;
-    if (boundTypeParameters.length != otherType.boundTypeParameters.length) {
-      return false;
-    }
-    // `<T>T -> T` should be equal to `<U>U -> U`
-    // To test this, we instantiate both types with the same (unique) type
-    // variables, and see if the result is equal.
-    if (boundTypeParameters.isNotEmpty) {
-      List<DartType> instantiateTypeArgs = new List<DartType>();
-      List<DartType> variablesThis = new List<DartType>();
-      List<DartType> variablesOther = new List<DartType>();
-      for (int i = 0; i < boundTypeParameters.length; i++) {
-        TypeParameterElement pThis = boundTypeParameters[i];
-        TypeParameterElement pOther = otherType.boundTypeParameters[i];
-        TypeParameterTypeImpl pFresh = new TypeParameterTypeImpl(
-            new TypeParameterElementImpl(pThis.name, -1));
-        instantiateTypeArgs.add(pFresh);
-        variablesThis.add(pThis.type);
-        variablesOther.add(pOther.type);
-        // Check that the bounds are equal after equating the previous
-        // bound variables.
-        if (pThis.bound?.substitute2(instantiateTypeArgs, variablesThis) !=
-            pOther.bound?.substitute2(instantiateTypeArgs, variablesOther)) {
-          return false;
-        }
-      }
-      // After instantiation, they will no longer have boundTypeParameters,
-      // so we will continue below.
-      return this.instantiate(instantiateTypeArgs) ==
-          otherType.instantiate(instantiateTypeArgs);
-    }
-
-    return returnType == otherType.returnType &&
-        TypeImpl.equalArrays(
-            normalParameterTypes, otherType.normalParameterTypes) &&
-        TypeImpl.equalArrays(
-            optionalParameterTypes, otherType.optionalParameterTypes) &&
-        _equals(namedParameterTypes, otherType.namedParameterTypes);
-  }
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    if (boundTypeParameters.isNotEmpty) {
-      // To print a type with type variables, first make sure we have unique
-      // variable names to print.
-      Set<TypeParameterType> freeVariables = new HashSet<TypeParameterType>();
-      _freeVariablesInFunctionType(this, freeVariables);
-
-      Set<String> namesToAvoid = new HashSet<String>();
-      for (DartType arg in freeVariables) {
-        if (arg is TypeParameterType) {
-          namesToAvoid.add(arg.displayName);
-        }
-      }
-
-      List<DartType> instantiateTypeArgs = new List<DartType>();
-      List<DartType> variables = new List<DartType>();
-      buffer.write("<");
-      for (TypeParameterElement e in boundTypeParameters) {
-        if (e != boundTypeParameters[0]) {
-          buffer.write(",");
-        }
-        String name = e.name;
-        int counter = 0;
-        while (!namesToAvoid.add(name)) {
-          // Unicode subscript-zero is U+2080, zero is U+0030. Other digits
-          // are sequential from there. Thus +0x2050 will get us the subscript.
-          String subscript = new String.fromCharCodes(
-              counter.toString().codeUnits.map((n) => n + 0x2050));
-
-          name = e.name + subscript;
-          counter++;
-        }
-        TypeParameterTypeImpl t =
-            new TypeParameterTypeImpl(new TypeParameterElementImpl(name, -1));
-        t.appendTo(buffer);
-        instantiateTypeArgs.add(t);
-        variables.add(e.type);
-        if (e.bound != null) {
-          buffer.write(" extends ");
-          TypeImpl renamed =
-              e.bound.substitute2(instantiateTypeArgs, variables);
-          renamed.appendTo(buffer);
-        }
-      }
-      buffer.write(">");
-
-      // Instantiate it and print the resulting type. After instantiation, it
-      // will no longer have boundTypeParameters, so we will continue below.
-      this.instantiate(instantiateTypeArgs).appendTo(buffer);
-      return;
-    }
-
-    List<DartType> normalParameterTypes = this.normalParameterTypes;
-    List<DartType> optionalParameterTypes = this.optionalParameterTypes;
-    Map<String, DartType> namedParameterTypes = this.namedParameterTypes;
-    DartType returnType = this.returnType;
-    buffer.write("(");
-    bool needsComma = false;
-    if (normalParameterTypes.isNotEmpty) {
-      for (DartType type in normalParameterTypes) {
-        if (needsComma) {
-          buffer.write(", ");
-        } else {
-          needsComma = true;
-        }
-        (type as TypeImpl).appendTo(buffer);
-      }
-    }
-    if (optionalParameterTypes.isNotEmpty) {
-      if (needsComma) {
-        buffer.write(", ");
-        needsComma = false;
-      }
-      buffer.write("[");
-      for (DartType type in optionalParameterTypes) {
-        if (needsComma) {
-          buffer.write(", ");
-        } else {
-          needsComma = true;
-        }
-        (type as TypeImpl).appendTo(buffer);
-      }
-      buffer.write("]");
-      needsComma = true;
-    }
-    if (namedParameterTypes.isNotEmpty) {
-      if (needsComma) {
-        buffer.write(", ");
-        needsComma = false;
-      }
-      buffer.write("{");
-      namedParameterTypes.forEach((String name, DartType type) {
-        if (needsComma) {
-          buffer.write(", ");
-        } else {
-          needsComma = true;
-        }
-        buffer.write(name);
-        buffer.write(": ");
-        (type as TypeImpl).appendTo(buffer);
-      });
-      buffer.write("}");
-      needsComma = true;
-    }
-    buffer.write(")");
-    buffer.write(ElementImpl.RIGHT_ARROW);
-    if (returnType == null) {
-      buffer.write("null");
-    } else {
-      (returnType as TypeImpl).appendTo(buffer);
-    }
-  }
-
-  @override
-  FunctionTypeImpl instantiate(List<DartType> argumentTypes) {
-    if (argumentTypes.length != boundTypeParameters.length) {
-      throw new IllegalArgumentException(
-          "argumentTypes.length (${argumentTypes.length}) != "
-          "boundTypeParameters.length (${boundTypeParameters.length})");
-    }
-    if (argumentTypes.isEmpty) {
-      return this;
-    }
-
-    // Given:
-    //     {U/T} <S> T -> S
-    // Where {U/T} represents the typeArguments (U) and typeParameters (T) list,
-    // and <S> represents the boundTypeParameters.
-    //
-    // Now instantiate([V]), and the result should be:
-    //     {U/T, V/S} T -> S.
-    List<TypeParameterElement> newTypeParams = typeParameters.toList();
-    List<DartType> newTypeArgs = typeArguments.toList();
-    newTypeParams.addAll(boundTypeParameters);
-    newTypeArgs.addAll(argumentTypes);
-
-    return new FunctionTypeImpl._(element, name, prunedTypedefs, newTypeArgs,
-        newTypeParams, TypeParameterElement.EMPTY_LIST);
-  }
-
-  @override
-  bool isAssignableTo(DartType type) {
-    // A function type T may be assigned to a function type S, written T <=> S,
-    // iff T <: S.
-    return isSubtypeOf(type);
-  }
-
-  @override
-  bool isMoreSpecificThan(DartType type,
-      [bool withDynamic = false, Set<Element> visitedElements]) {
-    // Note: visitedElements is only used for breaking recursion in the type
-    // hierarchy; we don't use it when recursing into the function type.
-
-    // 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! 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)
-              .isMoreSpecificThan(sTypes[i], withDynamic)) {
-            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)
-            .isMoreSpecificThan(namedTypesS[keyS], withDynamic)) {
-          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)
-              .isMoreSpecificThan(sTypes[i], withDynamic)) {
-            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++) {
-          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++) {
-          sAllTypes[i] = sOpTypes[j];
-        }
-        for (int i = 0; i < sAllTypes.length; i++) {
-          if (!(tAllTypes[i] as TypeImpl)
-              .isMoreSpecificThan(sAllTypes[i], withDynamic)) {
-            return false;
-          }
-        }
-      }
-    }
-    DartType tRetType = t.returnType;
-    DartType sRetType = s.returnType;
-    return sRetType.isVoid ||
-        (tRetType as TypeImpl).isMoreSpecificThan(sRetType, withDynamic);
-  }
-
-  @override
-  bool isSubtypeOf(DartType type) {
-    // 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! 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).isAssignableTo(sTypes[i])) {
-            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).isAssignableTo(namedTypesS[keyS])) {
-          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).isAssignableTo(sTypes[i])) {
-            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++) {
-          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++) {
-          sAllTypes[i] = sOpTypes[j];
-        }
-        for (int i = 0; i < sAllTypes.length; i++) {
-          if (!(tAllTypes[i] as TypeImpl).isAssignableTo(sAllTypes[i])) {
-            return false;
-          }
-        }
-      }
-    }
-    DartType tRetType = t.returnType;
-    DartType sRetType = s.returnType;
-    return sRetType.isVoid || (tRetType as TypeImpl).isAssignableTo(sRetType);
-  }
-
-  @override
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune) {
-    if (prune == null) {
-      return this;
-    } else if (prune.contains(element)) {
-      // Circularity found.  Prune the type declaration.
-      return new CircularTypeImpl();
-    } else {
-      // There should never be a reason to prune a type that has already been
-      // pruned, since pruning is only done when expanding a function type
-      // alias, and function type aliases are always expanded by starting with
-      // base types.
-      assert(this.prunedTypedefs == null);
-      List<DartType> typeArgs = typeArguments
-          .map((TypeImpl t) => t.pruned(prune))
-          .toList(growable: false);
-      return new FunctionTypeImpl._(element, name, prune, typeArgs,
-          _typeParameters, _boundTypeParameters);
-    }
-  }
-
-  @override
-  DartType substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) {
-    // Pruned types should only ever result from performing type variable
-    // substitution, and it doesn't make sense to substitute again after
-    // substituting once.
-    assert(this.prunedTypedefs == null);
-    if (argumentTypes.length != parameterTypes.length) {
-      throw new IllegalArgumentException(
-          "argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
-    }
-    Element element = this.element;
-    if (prune != null && prune.contains(element)) {
-      // Circularity found.  Prune the type declaration.
-      return new CircularTypeImpl();
-    }
-    if (argumentTypes.length == 0) {
-      return this.pruned(prune);
-    }
-    List<DartType> typeArgs =
-        TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
-    return new FunctionTypeImpl._(
-        element, name, prune, typeArgs, _typeParameters, _boundTypeParameters);
-  }
-
-  @override
-  FunctionTypeImpl substitute3(List<DartType> argumentTypes) =>
-      substitute2(argumentTypes, typeArguments);
-
-  void _freeVariablesInFunctionType(
-      FunctionType type, Set<TypeParameterType> free) {
-    // Make some fresh variables to avoid capture.
-    List<DartType> typeArgs = DartType.EMPTY_LIST;
-    if (type.boundTypeParameters.isNotEmpty) {
-      typeArgs = new List<DartType>.from(type.boundTypeParameters.map((e) =>
-          new TypeParameterTypeImpl(new TypeParameterElementImpl(e.name, -1))));
-
-      type = type.instantiate(typeArgs);
-    }
-
-    for (ParameterElement p in type.parameters) {
-      _freeVariablesInType(p.type, free);
-    }
-    _freeVariablesInType(type.returnType, free);
-
-    // Remove all of our bound variables.
-    free.removeAll(typeArgs);
-  }
-
-  void _freeVariablesInInterfaceType(
-      InterfaceType type, Set<TypeParameterType> free) {
-    for (DartType typeArg in type.typeArguments) {
-      _freeVariablesInType(typeArg, free);
-    }
-  }
-
-  void _freeVariablesInType(DartType type, Set<TypeParameterType> free) {
-    if (type is TypeParameterType) {
-      free.add(type);
-    } else if (type is FunctionType) {
-      _freeVariablesInFunctionType(type, free);
-    } else if (type is InterfaceType) {
-      _freeVariablesInInterfaceType(type, free);
-    }
-  }
-
-  /**
-   * Compute the least upper bound of types [f] and [g], both of which are
-   * known to be function types.
-   *
-   * In the event that f and g have different numbers of required parameters,
-   * `null` is returned, in which case the least upper bound is the interface
-   * type `Function`.
-   */
-  static FunctionType computeLeastUpperBound(FunctionType f, FunctionType g) {
-    // TODO(paulberry): implement this.
-    return null;
-  }
-
-  /**
-   * Return `true` if all of the name/type pairs in the first map ([firstTypes])
-   * are equal to the corresponding name/type pairs in the second map
-   * ([secondTypes]). The maps are expected to iterate over their entries in the
-   * same order in which those entries were added to the map.
-   */
-  static bool _equals(
-      Map<String, DartType> firstTypes, Map<String, DartType> secondTypes) {
-    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];
-      if (firstKey != secondKey || firstType != secondType) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
-
-/**
- * A concrete implementation of a [HideElementCombinator].
- */
-class HideElementCombinatorImpl implements HideElementCombinator {
-  /**
-   * The names that are not to be made visible in the importing library even if
-   * they are defined in the imported library.
-   */
-  List<String> hiddenNames = StringUtilities.EMPTY_ARRAY;
-
-  @override
-  String toString() {
-    StringBuffer buffer = new StringBuffer();
-    buffer.write("show ");
-    int count = hiddenNames.length;
-    for (int i = 0; i < count; i++) {
-      if (i > 0) {
-        buffer.write(", ");
-      }
-      buffer.write(hiddenNames[i]);
-    }
-    return buffer.toString();
-  }
-}
-
-/**
- * A concrete implementation of an [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;
-
-  /**
-   * The combinators that were specified as part of the import directive in the
-   * order in which they were specified.
-   */
-  List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_LIST;
-
-  /**
-   * The prefix that was specified as part of the import directive, or `null` if
-   * there was no prefix specified.
-   */
-  PrefixElement prefix;
-
-  /**
-   * Initialize a newly created import element at the given [offset].
-   * The offset may be `-1` if the import is synthetic.
-   */
-  ImportElementImpl(int offset) : super(null, offset);
-
-  /**
-   * Set whether this import is for a deferred library.
-   */
-  void set deferred(bool isDeferred) {
-    setModifier(Modifier.DEFERRED, isDeferred);
-  }
-
-  @override
-  String get identifier =>
-      "${(importedLibrary as LibraryElementImpl).identifier}@$nameOffset";
-
-  @override
-  bool get isDeferred => hasModifier(Modifier.DEFERRED);
-
-  @override
-  ElementKind get kind => ElementKind.IMPORT;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitImportElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write("import ");
-    (importedLibrary as LibraryElementImpl).appendTo(buffer);
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChild(prefix, visitor);
-  }
-}
-
-/**
- * A concrete implementation of an [InterfaceType].
- */
-class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
-  /**
-   * A list containing the actual types of the type arguments.
-   */
-  List<DartType> typeArguments = DartType.EMPTY_LIST;
-
-  /**
-   * The set of typedefs which should not be expanded when exploring this type,
-   * to avoid creating infinite types in response to self-referential typedefs.
-   */
-  final List<FunctionTypeAliasElement> prunedTypedefs;
-
-  /**
-   * Initialize a newly created type to be declared by the given [element].
-   */
-  InterfaceTypeImpl(ClassElement element, [this.prunedTypedefs])
-      : super(element, element.displayName);
-
-  /**
-   * Initialize a newly created type to have the given [name]. This constructor
-   * should only be used in cases where there is no declaration of the type.
-   */
-  InterfaceTypeImpl.named(String name)
-      : prunedTypedefs = null,
-        super(null, name);
-
-  /**
-   * Private constructor.
-   */
-  InterfaceTypeImpl._(Element element, String name, this.prunedTypedefs)
-      : super(element, name);
-
-  @override
-  List<PropertyAccessorElement> get accessors {
-    List<PropertyAccessorElement> accessors = element.accessors;
-    List<PropertyAccessorElement> members =
-        new List<PropertyAccessorElement>(accessors.length);
-    for (int i = 0; i < accessors.length; i++) {
-      members[i] = PropertyAccessorMember.from(accessors[i], this);
-    }
-    return members;
-  }
-
-  @override
-  List<ConstructorElement> get constructors {
-    List<ConstructorElement> constructors = element.constructors;
-    List<ConstructorElement> members =
-        new List<ConstructorElement>(constructors.length);
-    for (int i = 0; i < constructors.length; i++) {
-      members[i] = ConstructorMember.from(constructors[i], this);
-    }
-    return members;
-  }
-
-  @override
-  String get displayName {
-    String name = this.name;
-    List<DartType> typeArguments = this.typeArguments;
-    bool allDynamic = true;
-    for (DartType type in typeArguments) {
-      if (type != null && !type.isDynamic) {
-        allDynamic = false;
-        break;
-      }
-    }
-    // If there is at least one non-dynamic type, then list them out
-    if (!allDynamic) {
-      StringBuffer buffer = new StringBuffer();
-      buffer.write(name);
-      buffer.write("<");
-      for (int i = 0; i < typeArguments.length; i++) {
-        if (i != 0) {
-          buffer.write(", ");
-        }
-        DartType typeArg = typeArguments[i];
-        buffer.write(typeArg.displayName);
-      }
-      buffer.write(">");
-      name = buffer.toString();
-    }
-    return name;
-  }
-
-  @override
-  ClassElement get element => super.element as ClassElement;
-
-  @override
-  int get hashCode {
-    ClassElement element = this.element;
-    if (element == null) {
-      return 0;
-    }
-    return element.hashCode;
-  }
-
-  @override
-  List<InterfaceType> get interfaces {
-    ClassElement classElement = element;
-    List<InterfaceType> interfaces = classElement.interfaces;
-    List<TypeParameterElement> typeParameters = classElement.typeParameters;
-    List<DartType> parameterTypes = classElement.type.typeArguments;
-    if (typeParameters.length == 0) {
-      return interfaces;
-    }
-    int count = interfaces.length;
-    List<InterfaceType> typedInterfaces = new List<InterfaceType>(count);
-    for (int i = 0; i < count; i++) {
-      typedInterfaces[i] =
-          interfaces[i].substitute2(typeArguments, parameterTypes);
-    }
-    return typedInterfaces;
-  }
-
-  @override
-  bool get isDartCoreFunction {
-    ClassElement element = this.element;
-    if (element == null) {
-      return false;
-    }
-    return element.name == "Function" && element.library.isDartCore;
-  }
-
-  @override
-  bool get isObject => element.supertype == null;
-
-  @override
-  List<MethodElement> get methods {
-    List<MethodElement> methods = element.methods;
-    List<MethodElement> members = new List<MethodElement>(methods.length);
-    for (int i = 0; i < methods.length; i++) {
-      members[i] = MethodMember.from(methods[i], this);
-    }
-    return members;
-  }
-
-  @override
-  List<InterfaceType> get mixins {
-    ClassElement classElement = element;
-    List<InterfaceType> mixins = classElement.mixins;
-    List<TypeParameterElement> typeParameters = classElement.typeParameters;
-    List<DartType> parameterTypes = classElement.type.typeArguments;
-    if (typeParameters.length == 0) {
-      return mixins;
-    }
-    int count = mixins.length;
-    List<InterfaceType> typedMixins = new List<InterfaceType>(count);
-    for (int i = 0; i < count; i++) {
-      typedMixins[i] = mixins[i].substitute2(typeArguments, parameterTypes);
-    }
-    return typedMixins;
-  }
-
-  @override
-  InterfaceType get superclass {
-    ClassElement classElement = element;
-    InterfaceType supertype = classElement.supertype;
-    if (supertype == null) {
-      return null;
-    }
-    List<DartType> typeParameters = classElement.type.typeArguments;
-    if (typeArguments.length == 0 ||
-        typeArguments.length != typeParameters.length) {
-      return supertype;
-    }
-    return supertype.substitute2(typeArguments, typeParameters);
-  }
-
-  @override
-  List<TypeParameterElement> get typeParameters => element.typeParameters;
-
-  @override
-  bool operator ==(Object object) {
-    if (identical(object, this)) {
-      return true;
-    }
-    if (object is! InterfaceTypeImpl) {
-      return false;
-    }
-    InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
-    return (element == otherType.element) &&
-        TypeImpl.equalArrays(typeArguments, otherType.typeArguments);
-  }
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write(name);
-    int argumentCount = typeArguments.length;
-    if (argumentCount > 0) {
-      buffer.write("<");
-      for (int i = 0; i < argumentCount; i++) {
-        if (i > 0) {
-          buffer.write(", ");
-        }
-        (typeArguments[i] as TypeImpl).appendTo(buffer);
-      }
-      buffer.write(">");
-    }
-  }
-
-  @override
-  PropertyAccessorElement getGetter(String getterName) => PropertyAccessorMember
-      .from((element as ClassElementImpl).getGetter(getterName), this);
-
-  @override
-  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);
-
-  @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
-    // supertypes.
-    //
-    if (supertype == null) {
-      return false;
-    }
-    //
-    // I is listed in the extends clause of J.
-    //
-    List<DartType> jArgs = j.typeArguments;
-    List<DartType> jVars = jElement.type.typeArguments;
-    supertype = supertype.substitute2(jArgs, jVars);
-    if (supertype == i) {
-      return true;
-    }
-    //
-    // I is listed in the implements clause of J.
-    //
-    for (InterfaceType interfaceType in jElement.interfaces) {
-      interfaceType = interfaceType.substitute2(jArgs, jVars);
-      if (interfaceType == i) {
-        return true;
-      }
-    }
-    //
-    // I is listed in the with clause of J.
-    //
-    for (InterfaceType mixinType in jElement.mixins) {
-      mixinType = mixinType.substitute2(jArgs, jVars);
-      if (mixinType == i) {
-        return true;
-      }
-    }
-    //
-    // 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
-  bool isMoreSpecificThan(DartType type,
-      [bool withDynamic = false, Set<Element> visitedElements]) {
-    //
-    // 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;
-    }
-    //
-    // 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 == type) {
-      return true;
-    }
-    if (type is InterfaceType) {
-      //
-      // T is bottom. (This case is handled by the class BottomTypeImpl.)
-      //
-      // Direct supertype: S is a direct supertype of T.
-      //
-      if (type.isDirectSupertypeOf(this)) {
-        return true;
-      }
-      //
-      // Covariance: T is of the form I<T1, ..., Tn> and S is of the form
-      // I<S1, ..., Sn> and Ti << Si, 1 <= i <= n.
-      //
-      ClassElement tElement = this.element;
-      ClassElement sElement = type.element;
-      if (tElement == sElement) {
-        List<DartType> tArguments = typeArguments;
-        List<DartType> sArguments = type.typeArguments;
-        if (tArguments.length != sArguments.length) {
-          return false;
-        }
-        for (int i = 0; i < tArguments.length; i++) {
-          if (!(tArguments[i] as TypeImpl)
-              .isMoreSpecificThan(sArguments[i], withDynamic)) {
-            return false;
-          }
-        }
-        return true;
-      }
-    }
-    //
-    // Transitivity: T << U and U << S.
-    //
-    // First check for infinite loops
-    if (element == null) {
-      return false;
-    }
-    if (visitedElements == null) {
-      visitedElements = new HashSet<ClassElement>();
-    } else if (visitedElements.contains(element)) {
-      return false;
-    }
-    visitedElements.add(element);
-    try {
-      // 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.
-      InterfaceTypeImpl supertype = superclass;
-      if (supertype != null &&
-          supertype.isMoreSpecificThan(type, withDynamic, visitedElements)) {
-        return true;
-      }
-      for (InterfaceType interfaceType in interfaces) {
-        if ((interfaceType as InterfaceTypeImpl)
-            .isMoreSpecificThan(type, withDynamic, visitedElements)) {
-          return true;
-        }
-      }
-      for (InterfaceType mixinType in mixins) {
-        if ((mixinType as InterfaceTypeImpl)
-            .isMoreSpecificThan(type, withDynamic, visitedElements)) {
-          return true;
-        }
-      }
-      // If a type I includes an instance method named `call`, and the type of
-      // `call` is the function type F, then I is considered to be more specific
-      // than F.
-      MethodElement callMethod = getMethod('call');
-      if (callMethod != null && !callMethod.isStatic) {
-        FunctionTypeImpl callType = callMethod.type;
-        if (callType.isMoreSpecificThan(type, withDynamic, visitedElements)) {
-          return true;
-        }
-      }
-      return false;
-    } finally {
-      visitedElements.remove(element);
-    }
-  }
-
-  @override
-  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 element = getGetter(getterName);
-    if (element != null && element.isAccessibleIn(library)) {
-      return element;
-    }
-    return lookUpGetterInSuperclass(getterName, library);
-  }
-
-  @override
-  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;
-    while (supertype != null && !visitedClasses.contains(supertypeElement)) {
-      visitedClasses.add(supertypeElement);
-      PropertyAccessorElement element = supertype.getGetter(getterName);
-      if (element != null && element.isAccessibleIn(library)) {
-        return element;
-      }
-      for (InterfaceType mixin in supertype.mixins.reversed) {
-        element = mixin.getGetter(getterName);
-        if (element != null && element.isAccessibleIn(library)) {
-          return element;
-        }
-      }
-      supertype = supertype.superclass;
-      supertypeElement = supertype == null ? null : supertype.element;
-    }
-    return null;
-  }
-
-  @override
-  PropertyAccessorElement lookUpInheritedGetter(String name,
-      {LibraryElement library, bool thisType: true}) {
-    PropertyAccessorElement result;
-    if (thisType) {
-      result = lookUpGetter(name, library);
-    } else {
-      result = lookUpGetterInSuperclass(name, library);
-    }
-    if (result != null) {
-      return result;
-    }
-    return _lookUpMemberInInterfaces(this, false, library,
-        new HashSet<ClassElement>(), (InterfaceType t) => t.getGetter(name));
-  }
-
-  @override
-  ExecutableElement lookUpInheritedGetterOrMethod(String name,
-      {LibraryElement library}) {
-    ExecutableElement result =
-        lookUpGetter(name, library) ?? lookUpMethod(name, library);
-
-    if (result != null) {
-      return result;
-    }
-    return _lookUpMemberInInterfaces(
-        this,
-        false,
-        library,
-        new HashSet<ClassElement>(),
-        (InterfaceType t) => t.getGetter(name) ?? t.getMethod(name));
-  }
-
-  @override
-  MethodElement lookUpInheritedMethod(String name,
-      {LibraryElement library, bool thisType: true}) {
-    MethodElement result;
-    if (thisType) {
-      result = lookUpMethod(name, library);
-    } else {
-      result = lookUpMethodInSuperclass(name, library);
-    }
-    if (result != null) {
-      return result;
-    }
-    return _lookUpMemberInInterfaces(this, false, library,
-        new HashSet<ClassElement>(), (InterfaceType t) => t.getMethod(name));
-  }
-
-  @override
-  PropertyAccessorElement lookUpInheritedSetter(String name,
-      {LibraryElement library, bool thisType: true}) {
-    PropertyAccessorElement result;
-    if (thisType) {
-      result = lookUpSetter(name, library);
-    } else {
-      result = lookUpSetterInSuperclass(name, library);
-    }
-    if (result != null) {
-      return result;
-    }
-    return _lookUpMemberInInterfaces(this, false, library,
-        new HashSet<ClassElement>(), (t) => t.getSetter(name));
-  }
-
-  @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) {
-    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 element = getSetter(setterName);
-    if (element != null && element.isAccessibleIn(library)) {
-      return element;
-    }
-    return lookUpSetterInSuperclass(setterName, library);
-  }
-
-  @override
-  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 pruned(List<FunctionTypeAliasElement> prune) {
-    if (prune == null) {
-      return this;
-    } else {
-      // There should never be a reason to prune a type that has already been
-      // pruned, since pruning is only done when expanding a function type
-      // alias, and function type aliases are always expanded by starting with
-      // base types.
-      assert(this.prunedTypedefs == null);
-      InterfaceTypeImpl result = new InterfaceTypeImpl._(element, name, prune);
-      result.typeArguments =
-          typeArguments.map((TypeImpl t) => t.pruned(prune)).toList();
-      return result;
-    }
-  }
-
-  @override
-  InterfaceTypeImpl substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) {
-    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.pruned(prune);
-    }
-    List<DartType> newTypeArguments = TypeImpl.substitute(
-        typeArguments, argumentTypes, parameterTypes, prune);
-    if (JavaArrays.equals(newTypeArguments, typeArguments)) {
-      return this;
-    }
-    InterfaceTypeImpl newType = new InterfaceTypeImpl(element, prune);
-    newType.typeArguments = newTypeArguments;
-    return newType;
-  }
-
-  @override
-  InterfaceTypeImpl substitute4(List<DartType> argumentTypes) =>
-      substitute2(argumentTypes, typeArguments);
-
-  /**
-   * Compute the least upper bound of types [i] and [j], both of which are
-   * known to be interface types.
-   *
-   * In the event that the algorithm fails (which might occur due to a bug in
-   * the analyzer), `null` is returned.
-   */
-  static InterfaceType computeLeastUpperBound(
-      InterfaceType i, InterfaceType j) {
-    // compute set of supertypes
-    Set<InterfaceType> si = computeSuperinterfaceSet(i);
-    Set<InterfaceType> sj = computeSuperinterfaceSet(j);
-    // union si with i and sj with j
-    si.add(i);
-    sj.add(j);
-    // compute intersection, reference as set 's'
-    List<InterfaceType> s = _intersection(si, sj);
-    // for each element in Set s, compute the largest inheritance path to Object
-    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--) {
-      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];
-      }
-    }
-    // Should be impossible--there should always be exactly one type with the
-    // maximum depth.
-    assert(false);
-    return null;
-  }
-
-  /**
-   * Return the length of the longest inheritance path from the given [type] to
-   * Object.
-   *
-   * See [computeLeastUpperBound].
-   */
-  static int computeLongestInheritancePathToObject(InterfaceType type) =>
-      _computeLongestInheritancePathToObject(
-          type, 0, new HashSet<ClassElement>());
-
-  /**
-   * Returns the set of all superinterfaces of the given [type].
-   *
-   * See [computeLeastUpperBound].
-   */
-  static Set<InterfaceType> computeSuperinterfaceSet(InterfaceType type) =>
-      _computeSuperinterfaceSet(type, new HashSet<InterfaceType>());
-
-  /**
-   * 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) {
-    // TODO(paulberry): this needs to be deprecated and replaced with a method
-    // in [TypeSystem], since it relies on the deprecated functionality of
-    // [DartType.getLeastUpperBound].
-    if (first.element == second.element) {
-      return _leastUpperBound(first, second);
-    }
-    AnalysisContext context = first.element.context;
-    return context.typeSystem
-        .getLeastUpperBound(context.typeProvider, first, second);
-  }
-
-  /**
-   * Return the length of the longest inheritance path from a subtype of the
-   * given [type] to Object, where the given [depth] is the length of the
-   * longest path from the subtype to this type. The set of [visitedTypes] is
-   * used to prevent infinite recursion in the case of a cyclic type structure.
-   *
-   * See [computeLongestInheritancePathToObject], and [computeLeastUpperBound].
-   */
-  static int _computeLongestInheritancePathToObject(
-      InterfaceType type, int depth, HashSet<ClassElement> visitedTypes) {
-    ClassElement classElement = type.element;
-    // Object case
-    if (classElement.supertype == null || visitedTypes.contains(classElement)) {
-      return depth;
-    }
-    int longestPath = 1;
-    try {
-      visitedTypes.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, visitedTypes);
-          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, visitedTypes);
-      if (pathLength > longestPath) {
-        longestPath = pathLength;
-      }
-    } finally {
-      visitedTypes.remove(classElement);
-    }
-    return longestPath;
-  }
-
-  /**
-   * Add all of the superinterfaces of the given [type] to the given [set].
-   * Return the [set] as a convenience.
-   *
-   * See [computeSuperinterfaceSet], and [computeLeastUpperBound].
-   */
-  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 [first] and [second] sets of types, where
-   * intersection is based on the equality of the types themselves.
-   */
-  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);
-  }
-
-  /**
-   * 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) {
-    ClassElement firstElement = firstType.element;
-    ClassElement secondElement = secondType.element;
-    if (firstElement != secondElement) {
-      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;
-    }
-    List<DartType> lubArguments = new List<DartType>(argumentCount);
-    for (int i = 0; i < argumentCount; i++) {
-      //
-      // Ideally we would take the least upper bound of the two argument types,
-      // but this can cause an infinite recursion (such as when finding the
-      // least upper bound of String and num).
-      //
-      if (firstArguments[i] == secondArguments[i]) {
-        lubArguments[i] = firstArguments[i];
-      }
-      if (lubArguments[i] == null) {
-        lubArguments[i] = DynamicTypeImpl.instance;
-      }
-    }
-    InterfaceTypeImpl lub = new InterfaceTypeImpl(firstElement);
-    lub.typeArguments = lubArguments;
-    return lub;
-  }
-
-  /**
-   * Look up the getter with the given [name] in the interfaces
-   * implemented by the given [targetType], either directly or indirectly.
-   * Return the element representing the getter that was found, or `null` if
-   * there is no getter with the given name. The flag [includeTargetType] should
-   * be `true` if the search should include the target type. The
-   * [visitedInterfaces] is a set containing all of the interfaces that have
-   * been examined, used to prevent infinite recursion and to optimize the
-   * search.
-   */
-  static ExecutableElement _lookUpMemberInInterfaces(
-      InterfaceType targetType,
-      bool includeTargetType,
-      LibraryElement library,
-      HashSet<ClassElement> visitedInterfaces,
-      ExecutableElement getMember(InterfaceType type)) {
-    // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the
-    // specification (titled "Inheritance and Overriding" under "Interfaces")
-    // describes a much more complex scheme for finding the inherited member.
-    // We need to follow that scheme. The code below should cover the 80% case.
-    ClassElement targetClass = targetType.element;
-    if (!visitedInterfaces.add(targetClass)) {
-      return null;
-    }
-    if (includeTargetType) {
-      ExecutableElement member = getMember(targetType);
-      if (member != null && member.isAccessibleIn(library)) {
-        return member;
-      }
-    }
-    for (InterfaceType interfaceType in targetType.interfaces) {
-      ExecutableElement member = _lookUpMemberInInterfaces(
-          interfaceType, true, library, visitedInterfaces, getMember);
-      if (member != null) {
-        return member;
-      }
-    }
-    for (InterfaceType mixinType in targetType.mixins.reversed) {
-      ExecutableElement member = _lookUpMemberInInterfaces(
-          mixinType, true, library, visitedInterfaces, getMember);
-      if (member != null) {
-        return member;
-      }
-    }
-    InterfaceType superclass = targetType.superclass;
-    if (superclass == null) {
-      return null;
-    }
-    return _lookUpMemberInInterfaces(
-        superclass, true, library, visitedInterfaces, getMember);
-  }
-}
-
-/**
- * A concrete implementation of a [LabelElement].
- */
-class LabelElementImpl extends ElementImpl implements LabelElement {
-  /**
-   * A flag indicating whether this label is associated with a `switch`
-   * statement.
-   */
-  // TODO(brianwilkerson) Make this a modifier.
-  final bool _onSwitchStatement;
-
-  /**
-   * A flag indicating whether this label is associated with a `switch` member
-   * (`case` or `default`).
-   */
-  // TODO(brianwilkerson) Make this a modifier.
-  final bool _onSwitchMember;
-
-  /**
-   * Initialize a newly created label element to have the given [name].
-   * [onSwitchStatement] should be `true` if this label is associated with a
-   * `switch` statement and [onSwitchMember] should be `true` if this label is
-   * associated with a `switch` member.
-   */
-  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`).
-   */
-  bool get isOnSwitchMember => _onSwitchMember;
-
-  /**
-   * Return `true` if this label is associated with a `switch` statement.
-   */
-  bool get isOnSwitchStatement => _onSwitchStatement;
-
-  @override
-  ElementKind get kind => ElementKind.LABEL;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
-}
-
-/**
- * A concrete implementation of a [LibraryElement].
- */
-class LibraryElementImpl extends ElementImpl implements LibraryElement {
-  /**
-   * The analysis context in which this library is defined.
-   */
-  final AnalysisContext context;
-
-  /**
-   * The compilation unit that defines this library.
-   */
-  CompilationUnitElement _definingCompilationUnit;
-
-  /**
-   * The entry point for this library, or `null` if this library does not have
-   * an entry point.
-   */
-  FunctionElement entryPoint;
-
-  /**
-   * A list containing specifications of all of the imports defined in this
-   * library.
-   */
-  List<ImportElement> _imports = ImportElement.EMPTY_LIST;
-
-  /**
-   * A list containing specifications of all of the exports defined in this
-   * library.
-   */
-  List<ExportElement> _exports = ExportElement.EMPTY_LIST;
-
-  /**
-   * A list containing the strongly connected component in the import/export
-   * graph in which the current library resides.  Computed on demand, null
-   * if not present.  If _libraryCycle is set, then the _libraryCycle field
-   * for all libraries reachable from this library in the import/export graph
-   * is also set.
-   */
-  List<LibraryElement> _libraryCycle = null;
-
-  /**
-   * A list containing all of the compilation units that are included in this
-   * library using a `part` directive.
-   */
-  List<CompilationUnitElement> _parts = CompilationUnitElement.EMPTY_LIST;
-
-  /**
-   * The element representing the synthetic function `loadLibrary` that is
-   * defined for this library, or `null` if the element has not yet been created.
-   */
-  FunctionElement _loadLibraryFunction;
-
-  @override
-  final int nameLength;
-
-  /**
-   * The export [Namespace] of this library, `null` if it has not been
-   * computed yet.
-   */
-  @override
-  Namespace exportNamespace;
-
-  /**
-   * The public [Namespace] of this library, `null` if it has not been
-   * computed yet.
-   */
-  @override
-  Namespace publicNamespace;
-
-  /**
-   * Initialize a newly created library element in the given [context] to have
-   * the given [name] and [offset].
-   */
-  LibraryElementImpl(this.context, String name, int offset, this.nameLength)
-      : super(name, offset);
-
-  /**
-   * Initialize a newly created library element in the given [context] to have
-   * the given [name].
-   */
-  LibraryElementImpl.forNode(this.context, LibraryIdentifier name)
-      : super.forNode(name),
-        nameLength = name != null ? name.length : 0;
-
-  @override
-  CompilationUnitElement get definingCompilationUnit =>
-      _definingCompilationUnit;
-
-  /**
-   * Set the compilation unit that defines this library to the given compilation
-   * [unit].
-   */
-  void set definingCompilationUnit(CompilationUnitElement unit) {
-    assert((unit as CompilationUnitElementImpl).librarySource == unit.source);
-    (unit as CompilationUnitElementImpl).enclosingElement = this;
-    this._definingCompilationUnit = unit;
-  }
-
-  @override
-  List<LibraryElement> get exportedLibraries {
-    HashSet<LibraryElement> libraries = new HashSet<LibraryElement>();
-    for (ExportElement element in _exports) {
-      LibraryElement library = element.exportedLibrary;
-      if (library != null) {
-        libraries.add(library);
-      }
-    }
-    return new List.from(libraries);
-  }
-
-  @override
-  List<ExportElement> get exports => _exports;
-
-  /**
-   * Set the specifications of all of the exports defined in this library to the
-   * given list of [exports].
-   */
-  void set exports(List<ExportElement> exports) {
-    for (ExportElement exportElement in exports) {
-      (exportElement as ExportElementImpl).enclosingElement = this;
-    }
-    this._exports = exports;
-  }
-
-  @override
-  bool get hasExtUri => hasModifier(Modifier.HAS_EXT_URI);
-
-  /**
-   * Set whether this library has an import of a "dart-ext" URI.
-   */
-  void set hasExtUri(bool hasExtUri) {
-    setModifier(Modifier.HAS_EXT_URI, hasExtUri);
-  }
-
-  @override
-  int get hashCode => _definingCompilationUnit.hashCode;
-
-  @override
-  bool get hasLoadLibraryFunction {
-    if (_definingCompilationUnit.hasLoadLibraryFunction) {
-      return true;
-    }
-    for (int i = 0; i < _parts.length; i++) {
-      if (_parts[i].hasLoadLibraryFunction) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  String get identifier => _definingCompilationUnit.source.encoding;
-
-  @override
-  List<LibraryElement> get importedLibraries {
-    HashSet<LibraryElement> libraries = new HashSet<LibraryElement>();
-    for (ImportElement element in _imports) {
-      LibraryElement library = element.importedLibrary;
-      if (library != null) {
-        libraries.add(library);
-      }
-    }
-    return new List.from(libraries);
-  }
-
-  @override
-  List<ImportElement> get imports => _imports;
-
-  /**
-   * Set the specifications of all of the imports defined in this library to the
-   * given list of [imports].
-   */
-  void set imports(List<ImportElement> imports) {
-    for (ImportElement importElement in imports) {
-      (importElement as ImportElementImpl).enclosingElement = this;
-      PrefixElementImpl prefix = importElement.prefix as PrefixElementImpl;
-      if (prefix != null) {
-        prefix.enclosingElement = this;
-      }
-    }
-    this._imports = imports;
-  }
-
-  @override
-  bool get isBrowserApplication =>
-      entryPoint != null && isOrImportsBrowserLibrary;
-
-  @override
-  bool get isDartCore => name == "dart.core";
-
-  @override
-  bool get isInSdk =>
-      StringUtilities.startsWith5(name, 0, 0x64, 0x61, 0x72, 0x74, 0x2E);
-
-  /**
-   * Return `true` if the receiver directly or indirectly imports the
-   * 'dart:html' libraries.
-   */
-  bool get isOrImportsBrowserLibrary {
-    List<LibraryElement> visited = new List<LibraryElement>();
-    Source htmlLibSource = context.sourceFactory.forUri(DartSdk.DART_HTML);
-    visited.add(this);
-    for (int index = 0; index < visited.length; index++) {
-      LibraryElement library = visited[index];
-      Source source = library.definingCompilationUnit.source;
-      if (source == htmlLibSource) {
-        return true;
-      }
-      for (LibraryElement importedLibrary in library.importedLibraries) {
-        if (!visited.contains(importedLibrary)) {
-          visited.add(importedLibrary);
-        }
-      }
-      for (LibraryElement exportedLibrary in library.exportedLibraries) {
-        if (!visited.contains(exportedLibrary)) {
-          visited.add(exportedLibrary);
-        }
-      }
-    }
-    return false;
-  }
-
-  @override
-  ElementKind get kind => ElementKind.LIBRARY;
-
-  @override
-  LibraryElement get library => this;
-
-  List<LibraryElement> get libraryCycle {
-    if (_libraryCycle != null) {
-      return _libraryCycle;
-    }
-
-    // Global counter for this run of the algorithm
-    int counter = 0;
-    // The discovery times of each library
-    Map<LibraryElementImpl, int> indices = {};
-    // The set of scc candidates
-    Set<LibraryElementImpl> active = new Set();
-    // The stack of discovered elements
-    List<LibraryElementImpl> stack = [];
-    // For a given library that has not yet been processed by this run of the
-    // algorithm, compute the strongly connected components.
-    int scc(LibraryElementImpl library) {
-      int index = counter++;
-      int root = index;
-      indices[library] = index;
-      active.add(library);
-      stack.add(library);
-      void recurse(LibraryElementImpl child) {
-        if (!indices.containsKey(child)) {
-          // We haven't visited this child yet, so recurse on the child,
-          // returning the lowest numbered node reachable from the child.  If
-          // the child can reach a root which is lower numbered than anything
-          // we've reached so far, update the root.
-          root = min(root, scc(child));
-        } else if (active.contains(child)) {
-          // The child has been visited, but has not yet been placed into a
-          // component.  If the child is higher than anything we've seen so far
-          // update the root appropriately.
-          root = min(root, indices[child]);
-        }
-      }
-      // Recurse on all of the children in the import/export graph, filtering
-      // out those for which library cycles have already been computed.
-      library.exportedLibraries
-          .where((l) => l._libraryCycle == null)
-          .forEach(recurse);
-      library.importedLibraries
-          .where((l) => l._libraryCycle == null)
-          .forEach(recurse);
-
-      if (root == index) {
-        // This is the root of a strongly connected component.
-        // Pop the elements, and share the component across all
-        // of the elements.
-        List<LibraryElement> component = <LibraryElement>[];
-        LibraryElementImpl cur = null;
-        do {
-          cur = stack.removeLast();
-          active.remove(cur);
-          component.add(cur);
-          cur._libraryCycle = component;
-        } while (cur != library);
-      }
-      return root;
-    }
-    scc(library);
-    return _libraryCycle;
-  }
-
-  @override
-  FunctionElement get loadLibraryFunction {
-    assert(_loadLibraryFunction != null);
-    return _loadLibraryFunction;
-  }
-
-  @override
-  List<CompilationUnitElement> get parts => _parts;
-
-  /**
-   * Set the compilation units that are included in this library using a `part`
-   * directive to the given list of [parts].
-   */
-  void set parts(List<CompilationUnitElement> parts) {
-    for (CompilationUnitElement compilationUnit in parts) {
-      assert((compilationUnit as CompilationUnitElementImpl).librarySource ==
-          source);
-      (compilationUnit as CompilationUnitElementImpl).enclosingElement = this;
-    }
-    this._parts = parts;
-  }
-
-  @override
-  List<PrefixElement> get prefixes {
-    HashSet<PrefixElement> prefixes = new HashSet<PrefixElement>();
-    for (ImportElement element in _imports) {
-      PrefixElement prefix = element.prefix;
-      if (prefix != null) {
-        prefixes.add(prefix);
-      }
-    }
-    return new List.from(prefixes);
-  }
-
-  @override
-  Source get source {
-    if (_definingCompilationUnit == null) {
-      return null;
-    }
-    return _definingCompilationUnit.source;
-  }
-
-  @override
-  List<CompilationUnitElement> get units {
-    List<CompilationUnitElement> units = new List<CompilationUnitElement>();
-    units.add(_definingCompilationUnit);
-    units.addAll(_parts);
-    return units;
-  }
-
-  @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;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
-
-  /**
-   * Create the [FunctionElement] to be returned by [loadLibraryFunction],
-   * using types provided by [typeProvider].
-   */
-  void createLoadLibraryFunction(TypeProvider typeProvider) {
-    FunctionElementImpl function =
-        new FunctionElementImpl(FunctionElement.LOAD_LIBRARY_NAME, -1);
-    function.synthetic = true;
-    function.enclosingElement = this;
-    function.returnType = typeProvider.futureDynamicType;
-    function.type = new FunctionTypeImpl(function);
-    _loadLibraryFunction = function;
-  }
-
-  @override
-  ElementImpl getChild(String identifier) {
-    if ((_definingCompilationUnit as CompilationUnitElementImpl).identifier ==
-        identifier) {
-      return _definingCompilationUnit as CompilationUnitElementImpl;
-    }
-    for (CompilationUnitElement part in _parts) {
-      if ((part as CompilationUnitElementImpl).identifier == identifier) {
-        return part as CompilationUnitElementImpl;
-      }
-    }
-    for (ImportElement importElement in _imports) {
-      if ((importElement as ImportElementImpl).identifier == identifier) {
-        return importElement as ImportElementImpl;
-      }
-    }
-    for (ExportElement exportElement in _exports) {
-      if ((exportElement as ExportElementImpl).identifier == identifier) {
-        return exportElement as ExportElementImpl;
-      }
-    }
-    return null;
-  }
-
-  @override
-  List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) {
-    int count = _imports.length;
-    List<ImportElement> importList = new List<ImportElement>();
-    for (int i = 0; i < count; i++) {
-      if (identical(_imports[i].prefix, prefixElement)) {
-        importList.add(_imports[i]);
-      }
-    }
-    return importList;
-  }
-
-  @override
-  ClassElement getType(String className) {
-    ClassElement type = _definingCompilationUnit.getType(className);
-    if (type != null) {
-      return type;
-    }
-    for (CompilationUnitElement part in _parts) {
-      type = part.getType(className);
-      if (type != null) {
-        return type;
-      }
-    }
-    return null;
-  }
-
-  /** Given an update to this library which may have added or deleted edges
-   * in the import/export graph originating from this node only, remove any
-   * cached library cycles in the element model which may have been invalidated.
-   */
-  void invalidateLibraryCycles() {
-    if (_libraryCycle == null) {
-      // We have already invalidated this node, or we have never computed
-      // library cycle information for it.  In the former case, we're done. In
-      // the latter case, this node cannot be reachable from any node for which
-      // we have computed library cycle information.  Therefore, any edges added
-      // or deleted in the update causing this invalidation can only be edges to
-      // nodes which either have no library cycle information (and hence do not
-      // need invalidation), or which do not reach this node by any path.
-      // In either case, no further invalidation is needed.
-      return;
-    }
-    // If we have pre-computed library cycle information, then we must
-    // invalidate the information both on this element, and on certain
-    // other elements.  Edges originating at this node may have been
-    // added or deleted.  A deleted edge that points outside of this cycle
-    // cannot change the cycle information for anything outside of this cycle,
-    // and so it is sufficient to delete the cached library information on this
-    // cycle.  An added edge which points to another node within the cycle
-    // only invalidates the cycle.  An added edge which points to a node earlier
-    // in the topological sort of cycles induces no invalidation (since there
-    // are by definition no back edges from earlier cycles in the topological
-    // order, and hence no possible cycle can have been introduced.  The only
-    // remaining case is that we have added an edge to a node which is later
-    // in the topological sort of cycles.  This can induce cycles, since it
-    // represents a new back edge.  It would be sufficient to invalidate the
-    // cycle information for all nodes that are between the target and the
-    // node in the topological order.  For simplicity, we simply invalidate
-    // all nodes which are reachable from the the source node.
-    // Note that in the invalidation phase, we do not cut off when we encounter
-    // a node with no library cycle information, since we do not know whether
-    // we are in the case where invalidation has already been performed, or we
-    // are in the case where library cycles have simply never been computed from
-    // a newly reachable node.
-    Set<LibraryElementImpl> active = new HashSet();
-    void invalidate(LibraryElementImpl library) {
-      if (!active.add(library)) return;
-      if (library._libraryCycle != null) {
-        library._libraryCycle.forEach(invalidate);
-        library._libraryCycle = null;
-      }
-      library.exportedLibraries.forEach(invalidate);
-      library.importedLibraries.forEach(invalidate);
-    }
-    invalidate(this);
-  }
-
-  @override
-  bool isUpToDate(int timeStamp) {
-    Set<LibraryElement> visitedLibraries = new Set();
-    return _safeIsUpToDate(this, timeStamp, visitedLibraries);
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    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) {
-    // 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);
-      }
-    }
-    // add exported libraries
-    if (includeExports) {
-      for (ExportElement exportElement in _exports) {
-        LibraryElement exportedLibrary = exportElement.exportedLibrary;
-        if (exportedLibrary != null) {
-          (exportedLibrary as LibraryElementImpl)
-              ._addVisibleLibraries(visibleLibraries, true);
-        }
-      }
-    }
-  }
-
-  /**
-   * Return `true` if the given [library] is up to date with respect to the
-   * given [timeStamp]. The set of [visitedLibraries] is used to prevent
-   * infinite recursion in the case of mutually dependent 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)) {
-        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) {
-        if (!_safeIsUpToDate(importedLibrary, timeStamp, visitedLibraries)) {
-          return false;
-        }
-      }
-      // Check the exported libraries.
-      for (LibraryElement exportedLibrary in library.exportedLibraries) {
-        if (!_safeIsUpToDate(exportedLibrary, timeStamp, visitedLibraries)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-}
-
-/**
- * A concrete implementation of a [LocalVariableElement].
- */
-class LocalVariableElementImpl extends VariableElementImpl
-    implements 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.
-   */
-  int _visibleRangeLength = -1;
-
-  /**
-   * Initialize a newly created method element to have the given [name] and
-   * [offset].
-   */
-  LocalVariableElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created local variable element to have the given [name].
-   */
-  LocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  String get identifier {
-    int enclosingOffset =
-        enclosingElement != null ? enclosingElement.nameOffset : 0;
-    int delta = nameOffset - enclosingOffset;
-    return '${super.identifier}@$delta';
-  }
-
-  @override
-  bool get isPotentiallyMutatedInClosure =>
-      hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
-
-  @override
-  bool get isPotentiallyMutatedInScope =>
-      hasModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE);
-
-  @override
-  ElementKind get kind => ElementKind.LOCAL_VARIABLE;
-
-  @override
-  SourceRange get visibleRange {
-    if (_visibleRangeLength < 0) {
-      return null;
-    }
-    return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write(type);
-    buffer.write(" ");
-    buffer.write(displayName);
-  }
-
-  @override
-  VariableDeclaration computeNode() =>
-      getNodeMatching((node) => node is VariableDeclaration);
-
-  /**
-   * Specifies that this variable is potentially mutated somewhere in closure.
-   */
-  void markPotentiallyMutatedInClosure() {
-    setModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT, true);
-  }
-
-  /**
-   * Specifies that this variable is potentially mutated somewhere in its scope.
-   */
-  void markPotentiallyMutatedInScope() {
-    setModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE, true);
-  }
-
-  /**
-   * Set the visible range for this element to the range starting at the given
-   * [offset] with the given [length].
-   */
-  void setVisibleRange(int offset, int length) {
-    _visibleRangeOffset = offset;
-    _visibleRangeLength = length;
-  }
-}
-
-/**
- * An element defined in a parameterized type where the values of the type
- * parameters are known.
- */
-abstract class Member implements Element {
-  /**
-   * The element on which the parameterized element was created.
-   */
-  final Element _baseElement;
-
-  /**
-   * The type in which the element is defined.
-   */
-  final ParameterizedType _definingType;
-
-  /**
-   * Initialize a newly created element to represent a member, based on the
-   * [baseElement], defined by the [definingType].
-   */
-  Member(this._baseElement, this._definingType);
-
-  /**
-   * Return the element on which the parameterized element was created.
-   */
-  Element get baseElement => _baseElement;
-
-  @override
-  AnalysisContext get context => _baseElement.context;
-
-  /**
-   * Return the type in which the element is defined.
-   */
-  ParameterizedType get definingType => _definingType;
-
-  @override
-  String get displayName => _baseElement.displayName;
-
-  @override
-  SourceRange get docRange => _baseElement.docRange;
-
-  int get id => _baseElement.id;
-
-  @override
-  bool get isDeprecated => _baseElement.isDeprecated;
-
-  @override
-  bool get isOverride => _baseElement.isOverride;
-
-  @override
-  bool get isPrivate => _baseElement.isPrivate;
-
-  @override
-  bool get isPublic => _baseElement.isPublic;
-
-  @override
-  bool get isSynthetic => _baseElement.isSynthetic;
-
-  @override
-  ElementKind get kind => _baseElement.kind;
-
-  @override
-  LibraryElement get library => _baseElement.library;
-
-  @override
-  ElementLocation get location => _baseElement.location;
-
-  @override
-  List<ElementAnnotation> get metadata => _baseElement.metadata;
-
-  @override
-  String get name => _baseElement.name;
-
-  @override
-  int get nameLength => _baseElement.nameLength;
-
-  @override
-  int get nameOffset => _baseElement.nameOffset;
-
-  @override
-  Source get source => _baseElement.source;
-
-  @override
-  CompilationUnit get unit => _baseElement.unit;
-
-  @override
-  String computeDocumentationComment() =>
-      _baseElement.computeDocumentationComment();
-
-  @override
-  AstNode computeNode() => _baseElement.computeNode();
-
-  @override
-  Element getAncestor(Predicate<Element> predicate) =>
-      baseElement.getAncestor(predicate);
-
-  @override
-  String getExtendedDisplayName(String shortName) =>
-      _baseElement.getExtendedDisplayName(shortName);
-
-  @override
-  bool isAccessibleIn(LibraryElement library) =>
-      _baseElement.isAccessibleIn(library);
-
-  /**
-   * If the given [child] is not `null`, use the given [visitor] to visit it.
-   */
-  void safelyVisitChild(Element child, ElementVisitor visitor) {
-    // TODO(brianwilkerson) Make this private
-    if (child != null) {
-      child.accept(visitor);
-    }
-  }
-
-  /**
-   * Use the given [visitor] to visit all of the [children].
-   */
-  void safelyVisitChildren(List<Element> children, ElementVisitor visitor) {
-    // TODO(brianwilkerson) Make this private
-    if (children != null) {
-      for (Element child in children) {
-        child.accept(visitor);
-      }
-    }
-  }
-
-  /**
-   * Return the type that results from replacing the type parameters in the
-   * given [type] with the type arguments associated with this member.
-   */
-  DartType substituteFor(DartType type) {
-    if (type == null) {
-      return null;
-    }
-    List<DartType> argumentTypes = _definingType.typeArguments;
-    List<DartType> parameterTypes =
-        TypeParameterTypeImpl.getTypes(_definingType.typeParameters);
-    return type.substitute2(argumentTypes, parameterTypes);
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    // There are no children to visit
-  }
-}
-
-/**
- * A concrete implementation of a [MethodElement].
- */
-class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
-  /**
-   * Initialize a newly created method element to have the given [name] at the
-   * given [offset].
-   */
-  MethodElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created method element to have the given [name].
-   */
-  MethodElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  /**
-   * Set whether this method is abstract.
-   */
-  void set abstract(bool isAbstract) {
-    setModifier(Modifier.ABSTRACT, isAbstract);
-  }
-
-  @override
-  String get displayName {
-    String displayName = super.displayName;
-    if ("unary-" == displayName) {
-      return "-";
-    }
-    return displayName;
-  }
-
-  @override
-  ClassElement get enclosingElement => super.enclosingElement as ClassElement;
-
-  @override
-  bool get isOperator {
-    String name = displayName;
-    if (name.isEmpty) {
-      return false;
-    }
-    int first = name.codeUnitAt(0);
-    return !((0x61 <= first && first <= 0x7A) ||
-        (0x41 <= first && first <= 0x5A) ||
-        first == 0x5F ||
-        first == 0x24);
-  }
-
-  @override
-  bool get isStatic => hasModifier(Modifier.STATIC);
-
-  @override
-  ElementKind get kind => ElementKind.METHOD;
-
-  @override
-  String get name {
-    String name = super.name;
-    if (isOperator && name == "-") {
-      if (parameters.length == 0) {
-        return "unary-";
-      }
-    }
-    return super.name;
-  }
-
-  /**
-   * Set whether this method is static.
-   */
-  void set static(bool isStatic) {
-    setModifier(Modifier.STATIC, isStatic);
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write(displayName);
-    super.appendTo(buffer);
-  }
-
-  @override
-  MethodDeclaration computeNode() =>
-      getNodeMatching((node) => node is MethodDeclaration);
-}
-
-/**
- * A method element defined in a parameterized type where the values of the type
- * parameters are known.
- */
-class MethodMember extends ExecutableMember implements MethodElement {
-  /**
-   * Initialize a newly created element to represent a method, based on the
-   * [baseElement], defined by the [definingType]. If [type] is passed, it
-   * represents the full type of the member, and will take precedence over
-   * the [definingType].
-   */
-  MethodMember(MethodElement baseElement, InterfaceType definingType,
-      [DartType type])
-      : super(baseElement, definingType, type);
-
-  @override
-  MethodElement get baseElement => super.baseElement as MethodElement;
-
-  @override
-  ClassElement get enclosingElement => baseElement.enclosingElement;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
-
-  @override
-  MethodDeclaration computeNode() => baseElement.computeNode();
-
-  @override
-  String toString() {
-    MethodElement baseElement = this.baseElement;
-    List<ParameterElement> parameters = this.parameters;
-    FunctionType type = this.type;
-    StringBuffer buffer = new StringBuffer();
-    buffer.write(baseElement.enclosingElement.displayName);
-    buffer.write(".");
-    buffer.write(baseElement.displayName);
-    buffer.write("(");
-    int parameterCount = parameters.length;
-    for (int i = 0; i < parameterCount; i++) {
-      if (i > 0) {
-        buffer.write(", ");
-      }
-      buffer.write(parameters[i]);
-    }
-    buffer.write(")");
-    if (type != null) {
-      buffer.write(ElementImpl.RIGHT_ARROW);
-      buffer.write(type.returnType);
-    }
-    return buffer.toString();
-  }
-
-  /**
-   * 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 [definingType], create a method member representing the given
-   * method. Return the member that was created, or the base method if no member
-   * was created.
-   */
-  static MethodElement from(MethodElement method, InterfaceType definingType) {
-    if (method == null || definingType.typeArguments.length == 0) {
-      return method;
-    }
-    FunctionType baseType = method.type;
-    List<DartType> argumentTypes = definingType.typeArguments;
-    List<DartType> parameterTypes = definingType.element.type.typeArguments;
-    FunctionType substitutedType =
-        baseType.substitute2(argumentTypes, parameterTypes);
-    if (baseType == substitutedType) {
-      return method;
-    }
-    return new MethodMember(method, definingType, substitutedType);
-  }
-}
-
-/**
- * A concrete implementation of a [MultiplyDefinedElement].
- */
-class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
-  /**
-   * The unique integer identifier of this element.
-   */
-  final int id = ElementImpl._NEXT_ID++;
-
-  /**
-   * The analysis context in which the multiply defined elements are defined.
-   */
-  final AnalysisContext context;
-
-  /**
-   * The name of the conflicting elements.
-   */
-  String _name;
-
-  /**
-   * A list containing all of the elements that conflict.
-   */
-  final List<Element> conflictingElements;
-
-  /**
-   * Initialize a newly created element in the given [context] to represent a
-   * list of [conflictingElements].
-   */
-  MultiplyDefinedElementImpl(this.context, this.conflictingElements) {
-    _name = conflictingElements[0].name;
-  }
-
-  @override
-  String get displayName => _name;
-
-  @override
-  SourceRange get docRange => null;
-
-  @override
-  Element get enclosingElement => null;
-
-  @override
-  bool get isDeprecated => false;
-
-  @override
-  bool get isOverride => false;
-
-  @override
-  bool get isPrivate {
-    String name = displayName;
-    if (name == null) {
-      return false;
-    }
-    return Identifier.isPrivateName(name);
-  }
-
-  @override
-  bool get isPublic => !isPrivate;
-
-  @override
-  bool get isSynthetic => true;
-
-  @override
-  ElementKind get kind => ElementKind.ERROR;
-
-  @override
-  LibraryElement get library => null;
-
-  @override
-  ElementLocation get location => null;
-
-  @override
-  List<ElementAnnotation> get metadata => ElementAnnotation.EMPTY_LIST;
-
-  @override
-  String get name => _name;
-
-  @override
-  int get nameLength => displayName != null ? displayName.length : 0;
-
-  @override
-  int get nameOffset => -1;
-
-  @override
-  Source get source => null;
-
-  @override
-  DartType get type => DynamicTypeImpl.instance;
-
-  @override
-  CompilationUnit get unit => null;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
-
-  @override
-  String computeDocumentationComment() => null;
-
-  @override
-  AstNode computeNode() => null;
-
-  @override
-  Element getAncestor(Predicate<Element> predicate) => null;
-
-  @override
-  String getExtendedDisplayName(String shortName) {
-    if (shortName != null) {
-      return shortName;
-    }
-    return displayName;
-  }
-
-  @override
-  bool isAccessibleIn(LibraryElement library) {
-    for (Element element in conflictingElements) {
-      if (element.isAccessibleIn(library)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  String toString() {
-    StringBuffer buffer = new StringBuffer();
-    buffer.write("[");
-    int count = conflictingElements.length;
-    for (int i = 0; i < count; i++) {
-      if (i > 0) {
-        buffer.write(", ");
-      }
-      (conflictingElements[i] as ElementImpl).appendTo(buffer);
-    }
-    buffer.write("]");
-    return buffer.toString();
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    // There are no children to visit
-  }
-
-  /**
-   * Return an element in the given [context] that represents the fact that the
-   * [firstElement] and [secondElement] conflict. (If the elements are the same,
-   * then one of the two will be returned directly.)
-   */
-  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);
-  }
-
-  /**
-   * Add the given [element] to the list of [elements]. If the element is a
-   * multiply-defined element, add all of the conflicting elements that it
-   * represents.
-   */
-  static void _add(HashSet<Element> elements, Element element) {
-    if (element is MultiplyDefinedElementImpl) {
-      for (Element conflictingElement in element.conflictingElements) {
-        elements.add(conflictingElement);
-      }
-    } else {
-      elements.add(element);
-    }
-  }
-
-  /**
-   * Use the given elements to construct a list of conflicting elements. If
-   * either the [firstElement] or [secondElement] are multiply-defined elements
-   * then the conflicting elements they represent will be included in the array.
-   * Otherwise, the element itself will be included.
-   */
-  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);
-  }
-}
-
-/**
- * A [MethodElementImpl], with the additional information of a list of
- * [ExecutableElement]s from which this element was composed.
- */
-class MultiplyInheritedMethodElementImpl extends MethodElementImpl
-    implements MultiplyInheritedExecutableElement {
-  /**
-   * A list the array of executable elements that were used to compose this
-   * element.
-   */
-  List<ExecutableElement> _elements = MethodElement.EMPTY_LIST;
-
-  MultiplyInheritedMethodElementImpl(Identifier name) : super.forNode(name) {
-    synthetic = true;
-  }
-
-  @override
-  List<ExecutableElement> get inheritedElements => _elements;
-
-  void set inheritedElements(List<ExecutableElement> elements) {
-    this._elements = elements;
-  }
-}
-
-/**
- * A [PropertyAccessorElementImpl], with the additional information of a list of
- * [ExecutableElement]s from which this element was composed.
- */
-class MultiplyInheritedPropertyAccessorElementImpl
-    extends PropertyAccessorElementImpl
-    implements MultiplyInheritedExecutableElement {
-  /**
-   * A list the array of executable elements that were used to compose this
-   * element.
-   */
-  List<ExecutableElement> _elements = PropertyAccessorElement.EMPTY_LIST;
-
-  MultiplyInheritedPropertyAccessorElementImpl(Identifier name)
-      : super.forNode(name) {
-    synthetic = true;
-  }
-
-  @override
-  List<ExecutableElement> get inheritedElements => _elements;
-
-  void set inheritedElements(List<ExecutableElement> elements) {
-    this._elements = elements;
-  }
-}
-
-/**
- * A concrete implementation of a [ParameterElement].
- */
-class ParameterElementImpl extends VariableElementImpl
-    with ParameterElementMixin
-    implements ParameterElement {
-  /**
-   * A list 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 = ParameterElement.EMPTY_LIST;
-
-  /**
-   * A list containing all of the type parameters defined for this parameter
-   * element. There will only be parameters if this parameter is a function
-   * typed parameter.
-   */
-  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
-
-  /**
-   * The kind of this parameter.
-   */
-  ParameterKind parameterKind;
-
-  /**
-   * The Dart code of the default value.
-   */
-  String _defaultValueCode;
-
-  /**
-   * 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.
-   */
-  int _visibleRangeLength = -1;
-
-  /**
-   * Initialize a newly created parameter element to have the given [name] and
-   * [offset].
-   */
-  ParameterElementImpl(String name, int nameOffset) : super(name, nameOffset);
-
-  /**
-   * Initialize a newly created parameter element to have the given [name].
-   */
-  ParameterElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  String get defaultValueCode => _defaultValueCode;
-
-  /**
-   * Set Dart code of the default value.
-   */
-  void set defaultValueCode(String defaultValueCode) {
-    this._defaultValueCode = StringUtilities.intern(defaultValueCode);
-  }
-
-  @override
-  bool get isInitializingFormal => false;
-
-  @override
-  bool get isPotentiallyMutatedInClosure =>
-      hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
-
-  @override
-  bool get isPotentiallyMutatedInScope =>
-      hasModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE);
-
-  @override
-  ElementKind get kind => ElementKind.PARAMETER;
-
-  @override
-  List<ParameterElement> get parameters => _parameters;
-
-  /**
-   * Set the parameters defined by this executable element to the given
-   * [parameters].
-   */
-  void set parameters(List<ParameterElement> parameters) {
-    for (ParameterElement parameter in parameters) {
-      (parameter as ParameterElementImpl).enclosingElement = this;
-    }
-    this._parameters = parameters;
-  }
-
-  @override
-  List<TypeParameterElement> get typeParameters => _typeParameters;
-
-  /**
-   * Set the type parameters defined by this parameter element to the given
-   * [typeParameters].
-   */
-  void set typeParameters(List<TypeParameterElement> typeParameters) {
-    for (TypeParameterElement parameter in typeParameters) {
-      (parameter as TypeParameterElementImpl).enclosingElement = this;
-    }
-    this._typeParameters = typeParameters;
-  }
-
-  @override
-  SourceRange get visibleRange {
-    if (_visibleRangeLength < 0) {
-      return null;
-    }
-    return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
-
-  @override
-  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) {}
-      break;
-    }
-    buffer.write(left);
-    appendToWithoutDelimiters(buffer);
-    buffer.write(right);
-  }
-
-  @override
-  FormalParameter computeNode() =>
-      getNodeMatching((node) => node is FormalParameter);
-
-  @override
-  ElementImpl getChild(String identifier) {
-    for (ParameterElement parameter in _parameters) {
-      if ((parameter as ParameterElementImpl).identifier == identifier) {
-        return parameter as ParameterElementImpl;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Specifies that this variable is potentially mutated somewhere in closure.
-   */
-  void markPotentiallyMutatedInClosure() {
-    setModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT, true);
-  }
-
-  /**
-   * Specifies that this variable is potentially mutated somewhere in its scope.
-   */
-  void markPotentiallyMutatedInScope() {
-    setModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE, true);
-  }
-
-  /**
-   * Set the visible range for this element to the range starting at the given
-   * [offset] with the given [length].
-   */
-  void setVisibleRange(int offset, int length) {
-    _visibleRangeOffset = offset;
-    _visibleRangeLength = length;
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChildren(_parameters, visitor);
-  }
-}
-
-/**
- * A mixin that provides a common implementation for methods defined in
- * [ParameterElement].
- */
-abstract class ParameterElementMixin implements ParameterElement {
-  @override
-  void appendToWithoutDelimiters(StringBuffer buffer) {
-    buffer.write(type);
-    buffer.write(" ");
-    buffer.write(displayName);
-    if (defaultValueCode != null) {
-      if (parameterKind == ParameterKind.NAMED) {
-        buffer.write(": ");
-      }
-      if (parameterKind == ParameterKind.POSITIONAL) {
-        buffer.write(" = ");
-      }
-      buffer.write(defaultValueCode);
-    }
-  }
-}
-
-/**
- * A parameter element defined in a parameterized type where the values of the
- * type parameters are known.
- */
-class ParameterMember extends VariableMember
-    with ParameterElementMixin
-    implements ParameterElement {
-  /**
-   * Initialize a newly created element to represent a parameter, based on the
-   * [baseElement], defined by the [definingType]. If [type] is passed it will
-   * represent the already substituted type.
-   */
-  ParameterMember(ParameterElement baseElement, ParameterizedType definingType,
-      [DartType type])
-      : super._(baseElement, definingType, type);
-
-  @override
-  ParameterElement get baseElement => super.baseElement as ParameterElement;
-
-  @override
-  String get defaultValueCode => baseElement.defaultValueCode;
-
-  @override
-  Element get enclosingElement => baseElement.enclosingElement;
-
-  @override
-  int get hashCode => baseElement.hashCode;
-
-  @override
-  bool get isInitializingFormal => baseElement.isInitializingFormal;
-
-  @override
-  ParameterKind get parameterKind => baseElement.parameterKind;
-
-  @override
-  List<ParameterElement> get parameters {
-    DartType type = this.type;
-    if (type is FunctionType) {
-      return type.parameters;
-    }
-    return ParameterElement.EMPTY_LIST;
-  }
-
-  @override
-  List<TypeParameterElement> get typeParameters => baseElement.typeParameters;
-
-  @override
-  SourceRange get visibleRange => baseElement.visibleRange;
-
-  // TODO(jmesserly): this equality is broken. It should consider the defining
-  // type as well, otherwise we're dropping the substitution.
-  @override
-  bool operator ==(Object object) =>
-      object is ParameterMember && baseElement == object.baseElement;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
-
-  @override
-  FormalParameter computeNode() => baseElement.computeNode();
-
-  @override
-  Element getAncestor(Predicate<Element> predicate) {
-    Element element = baseElement.getAncestor(predicate);
-    ParameterizedType definingType = this.definingType;
-    if (definingType is InterfaceType) {
-      InterfaceType definingInterfaceType = definingType;
-      if (element is ConstructorElement) {
-        return ConstructorMember.from(element, definingInterfaceType);
-      } else if (element is MethodElement) {
-        return MethodMember.from(element, definingInterfaceType);
-      } else if (element is PropertyAccessorElement) {
-        return PropertyAccessorMember.from(element, definingInterfaceType);
-      }
-    }
-    return element;
-  }
-
-  @override
-  String toString() {
-    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) {}
-      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 [definingType], create a parameter member representing
-   * the given parameter. Return the member that was created, or the base
-   * parameter if no member was created.
-   */
-  static ParameterElement from(
-      ParameterElement parameter, ParameterizedType definingType) {
-    if (parameter == null || definingType.typeArguments.length == 0) {
-      return parameter;
-    }
-    // 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.
-    if (parameter is FieldFormalParameterElement) {
-      return new FieldFormalParameterMember(parameter, definingType);
-    } else {
-      DartType baseType = parameter.type;
-      List<DartType> argumentTypes = definingType.typeArguments;
-      List<DartType> parameterTypes =
-          TypeParameterTypeImpl.getTypes(definingType.typeParameters);
-      DartType substitutedType =
-          baseType.substitute2(argumentTypes, parameterTypes);
-      if (baseType == substitutedType) {
-        return parameter;
-      }
-      return new ParameterMember(parameter, definingType, substitutedType);
-    }
-  }
-}
-
-/**
- * A concrete implementation of a [PrefixElement].
- */
-class PrefixElementImpl extends ElementImpl implements PrefixElement {
-  /**
-   * A list containing all of the libraries that are imported using this prefix.
-   */
-  List<LibraryElement> _importedLibraries = LibraryElement.EMPTY_LIST;
-
-  /**
-   * Initialize a newly created method element to have the given [name] and
-   * [offset].
-   */
-  PrefixElementImpl(String name, int nameOffset) : super(name, nameOffset);
-
-  /**
-   * Initialize a newly created prefix element to have the given [name].
-   */
-  PrefixElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  LibraryElement get enclosingElement =>
-      super.enclosingElement as LibraryElement;
-
-  @override
-  String get identifier => "_${super.identifier}";
-
-  @override
-  List<LibraryElement> get importedLibraries => _importedLibraries;
-
-  /**
-   * Set the libraries that are imported using this prefix to the given
-   * [libraries].
-   */
-  void set importedLibraries(List<LibraryElement> libraries) {
-    for (LibraryElement library in libraries) {
-      (library as LibraryElementImpl).enclosingElement = this;
-    }
-    _importedLibraries = libraries;
-  }
-
-  @override
-  ElementKind get kind => ElementKind.PREFIX;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write("as ");
-    super.appendTo(buffer);
-  }
-}
-
-/**
- * A concrete implementation of a [PropertyAccessorElement].
- */
-class PropertyAccessorElementImpl extends ExecutableElementImpl
-    implements PropertyAccessorElement {
-  /**
-   * The variable associated with this accessor.
-   */
-  PropertyInducingElement variable;
-
-  /**
-   * Initialize a newly created property accessor element to have the given
-   * [name].
-   */
-  PropertyAccessorElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  /**
-   * Initialize a newly created synthetic property accessor element to be
-   * associated with the given [variable].
-   */
-  PropertyAccessorElementImpl.forVariable(PropertyInducingElementImpl variable)
-      : super(variable.name, variable.nameOffset) {
-    this.variable = variable;
-    static = variable.isStatic;
-    synthetic = true;
-  }
-
-  /**
-   * Set whether this accessor is abstract.
-   */
-  void set abstract(bool isAbstract) {
-    setModifier(Modifier.ABSTRACT, isAbstract);
-  }
-
-  @override
-  PropertyAccessorElement get correspondingGetter {
-    if (isGetter || variable == null) {
-      return null;
-    }
-    return variable.getter;
-  }
-
-  @override
-  PropertyAccessorElement get correspondingSetter {
-    if (isSetter || variable == null) {
-      return null;
-    }
-    return variable.setter;
-  }
-
-  /**
-   * Set whether this accessor is a getter.
-   */
-  void set getter(bool isGetter) {
-    setModifier(Modifier.GETTER, isGetter);
-  }
-
-  @override
-  int get hashCode => JenkinsSmiHash.hash2(super.hashCode, isGetter ? 1 : 2);
-
-  @override
-  String get identifier {
-    String name = displayName;
-    String suffix = isGetter ? "?" : "=";
-    return "$name$suffix";
-  }
-
-  @override
-  bool get isGetter => hasModifier(Modifier.GETTER);
-
-  @override
-  bool get isSetter => hasModifier(Modifier.SETTER);
-
-  @override
-  bool get isStatic => hasModifier(Modifier.STATIC);
-
-  @override
-  ElementKind get kind {
-    if (isGetter) {
-      return ElementKind.GETTER;
-    }
-    return ElementKind.SETTER;
-  }
-
-  @override
-  String get name {
-    if (isSetter) {
-      return "${super.name}=";
-    }
-    return super.name;
-  }
-
-  /**
-   * Set whether this accessor is a setter.
-   */
-  void set setter(bool isSetter) {
-    setModifier(Modifier.SETTER, isSetter);
-  }
-
-  /**
-   * Set whether this accessor is static.
-   */
-  void set static(bool isStatic) {
-    setModifier(Modifier.STATIC, isStatic);
-  }
-
-  @override
-  bool operator ==(Object object) =>
-      super == object &&
-      isGetter == (object as PropertyAccessorElement).isGetter;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write(isGetter ? "get " : "set ");
-    buffer.write(variable.displayName);
-    super.appendTo(buffer);
-  }
-
-  @override
-  AstNode computeNode() {
-    if (isSynthetic) {
-      return null;
-    }
-    if (enclosingElement is ClassElement) {
-      return getNodeMatching((node) => node is MethodDeclaration);
-    }
-    if (enclosingElement is CompilationUnitElement) {
-      return getNodeMatching((node) => node is FunctionDeclaration);
-    }
-    return null;
-  }
-}
-
-/**
- * A property accessor element defined in a parameterized type where the values
- * of the type parameters are known.
- */
-class PropertyAccessorMember extends ExecutableMember
-    implements PropertyAccessorElement {
-  /**
-   * Initialize a newly created element to represent a property, based on the
-   * [baseElement], defined by the [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);
-
-  @override
-  PropertyAccessorElement get correspondingSetter =>
-      from(baseElement.correspondingSetter, definingType);
-
-  @override
-  InterfaceType get definingType => super.definingType as InterfaceType;
-
-  @override
-  Element get enclosingElement => baseElement.enclosingElement;
-
-  @override
-  bool get isGetter => baseElement.isGetter;
-
-  @override
-  bool get isSetter => baseElement.isSetter;
-
-  @override
-  PropertyInducingElement get variable {
-    PropertyInducingElement variable = baseElement.variable;
-    if (variable is FieldElement) {
-      return FieldMember.from(variable, definingType);
-    }
-    return variable;
-  }
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
-
-  @override
-  String toString() {
-    PropertyAccessorElement baseElement = this.baseElement;
-    List<ParameterElement> parameters = this.parameters;
-    FunctionType type = this.type;
-    StringBuffer builder = new StringBuffer();
-    if (isGetter) {
-      builder.write("get ");
-    } else {
-      builder.write("set ");
-    }
-    builder.write(baseElement.enclosingElement.displayName);
-    builder.write(".");
-    builder.write(baseElement.displayName);
-    builder.write("(");
-    int parameterCount = parameters.length;
-    for (int i = 0; i < parameterCount; i++) {
-      if (i > 0) {
-        builder.write(", ");
-      }
-      builder.write(parameters[i]);
-    }
-    builder.write(")");
-    if (type != null) {
-      builder.write(ElementImpl.RIGHT_ARROW);
-      builder.write(type.returnType);
-    }
-    return builder.toString();
-  }
-
-  /**
-   * If the given [accessor]'s type is different when any type parameters from
-   * the defining type's declaration are replaced with the actual type
-   * arguments from the [definingType], create an accessor member representing
-   * the given accessor. Return the member that was created, or the base
-   * accessor if no member was created.
-   */
-  static PropertyAccessorElement from(
-      PropertyAccessorElement accessor, InterfaceType definingType) {
-    if (!_isChangedByTypeSubstitution(accessor, definingType)) {
-      return accessor;
-    }
-    // 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(accessor, 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 [definingType].
-   */
-  static bool _isChangedByTypeSubstitution(
-      PropertyAccessorElement accessor, InterfaceType definingType) {
-    List<DartType> argumentTypes = definingType.typeArguments;
-    if (accessor != null && argumentTypes.length != 0) {
-      FunctionType baseType = accessor.type;
-      if (baseType == null) {
-        AnalysisEngine.instance.logger.logInformation(
-            'Type of $accessor is null in PropertyAccessorMember._isChangedByTypeSubstitution');
-        return false;
-      }
-      List<DartType> parameterTypes = definingType.element.type.typeArguments;
-      FunctionType substitutedType =
-          baseType.substitute2(argumentTypes, parameterTypes);
-      if (baseType != substitutedType) {
-        return true;
-      }
-      // If this property accessor is based on a field, that field might have a
-      // propagated type. In which case we need to check whether the propagated
-      // type of the field needs substitution.
-      PropertyInducingElement field = accessor.variable;
-      if (!field.isSynthetic) {
-        DartType baseFieldType = field.propagatedType;
-        if (baseFieldType != null) {
-          DartType substitutedFieldType =
-              baseFieldType.substitute2(argumentTypes, parameterTypes);
-          if (baseFieldType != substitutedFieldType) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  }
-}
-
-/**
- * A concrete implementation of a [PropertyInducingElement].
- */
-abstract class PropertyInducingElementImpl extends VariableElementImpl
-    implements 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.
-   */
-  PropertyAccessorElement setter;
-
-  /**
-   * The propagated type of this variable, or `null` if type propagation has not
-   * been performed.
-   */
-  DartType propagatedType;
-
-  /**
-   * Initialize a newly created synthetic element to have the given [name] and
-   * [offset].
-   */
-  PropertyInducingElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created element to have the given [name].
-   */
-  PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
-}
-
-/**
- * A concrete implementation of a [ShowElementCombinator].
- */
-class ShowElementCombinatorImpl implements ShowElementCombinator {
-  /**
-   * The names that are to be made visible in the importing library if they are
-   * defined in the imported library.
-   */
-  List<String> shownNames = StringUtilities.EMPTY_ARRAY;
-
-  /**
-   * The offset of the character immediately following the last character of
-   * this node.
-   */
-  int end = -1;
-
-  /**
-   * The offset of the 'show' keyword of this element.
-   */
-  int offset = 0;
-
-  @override
-  String toString() {
-    StringBuffer buffer = new StringBuffer();
-    buffer.write("show ");
-    int count = shownNames.length;
-    for (int i = 0; i < count; i++) {
-      if (i > 0) {
-        buffer.write(", ");
-      }
-      buffer.write(shownNames[i]);
-    }
-    return buffer.toString();
-  }
-}
-
-/**
- * A concrete implementation of a [TopLevelVariableElement].
- */
-class TopLevelVariableElementImpl extends PropertyInducingElementImpl
-    implements TopLevelVariableElement {
-  /**
-   * Initialize a newly created synthetic top-level variable element to have the
-   * given [name] and [offset].
-   */
-  TopLevelVariableElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created top-level variable element to have the given
-   * [name].
-   */
-  TopLevelVariableElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  bool get isStatic => true;
-
-  @override
-  ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
-
-  @override
-  VariableDeclaration computeNode() =>
-      getNodeMatching((node) => node is VariableDeclaration);
-}
-
-/**
- * The abstract class `TypeImpl` implements the behavior common to objects
- * representing the declared type of elements in the element model.
- */
-abstract class TypeImpl implements DartType {
-  /**
-   * The element representing the declaration of this type, or `null` if the
-   * type has not, or cannot, be associated with an element.
-   */
-  final Element _element;
-
-  /**
-   * The name of this type, or `null` if the type does not have a name.
-   */
-  final String name;
-
-  /**
-   * Initialize a newly created type to be declared by the given [element] and
-   * to have the given [name].
-   */
-  TypeImpl(this._element, this.name);
-
-  @override
-  String get displayName => name;
-
-  @override
-  Element get element => _element;
-
-  @override
-  bool get isBottom => false;
-
-  @override
-  bool get isDartCoreFunction => false;
-
-  @override
-  bool get isDynamic => false;
-
-  @override
-  bool get isObject => false;
-
-  @override
-  bool get isUndefined => false;
-
-  @override
-  bool get isVoid => false;
-
-  /**
-   * Append a textual representation of this type to the given [buffer]. The set
-   * of [visitedTypes] is used to prevent infinite recursion.
-   */
-  void appendTo(StringBuffer buffer) {
-    if (name == null) {
-      buffer.write("<unnamed type>");
-    } else {
-      buffer.write(name);
-    }
-  }
-
-  /**
-   * Return `true` if this type is assignable to the given [type] (written in
-   * the spec as "T <=> S", where T=[this] and S=[type]).
-   *
-   * The sets [thisExpansions] and [typeExpansions], if given, are the sets of
-   * function type aliases that have been expanded so far in the process of
-   * reaching [this] and [type], respectively.  These are used to avoid
-   * infinite regress when analyzing invalid code; since the language spec
-   * forbids a typedef from referring to itself directly or indirectly, we can
-   * use these as sets of function type aliases that don't need to be expanded.
-   */
-  @override
-  bool isAssignableTo(DartType type) {
-    // An interface type T may be assigned to a type S, written T <=> S, iff
-    // either T <: S or S <: T.
-    return isSubtypeOf(type) || (type as TypeImpl).isSubtypeOf(this);
-  }
-
-  /**
-   * Return `true` if this type is more specific than the given [type] (written
-   * in the spec as "T << S", where T=[this] and S=[type]).
-   *
-   * If [withDynamic] is `true`, then "dynamic" should be considered as a
-   * subtype of any type (as though "dynamic" had been replaced with bottom).
-   *
-   * The set [visitedElements], if given, is the set of classes and type
-   * parameters that have been visited so far while examining the class
-   * hierarchy of [this].  This is used to avoid infinite regress when
-   * analyzing invalid code; since the language spec forbids loops in the class
-   * hierarchy, we can use this as a set of classes that don't need to be
-   * examined when walking the class hierarchy.
-   */
-  @override
-  bool isMoreSpecificThan(DartType type,
-      [bool withDynamic = false, Set<Element> visitedElements]);
-
-  /**
-   * Return `true` if this type is a subtype of the given [type] (written in
-   * the spec as "T <: S", where T=[this] and S=[type]).
-   *
-   * The sets [thisExpansions] and [typeExpansions], if given, are the sets of
-   * function type aliases that have been expanded so far in the process of
-   * reaching [this] and [type], respectively.  These are used to avoid
-   * infinite regress when analyzing invalid code; since the language spec
-   * forbids a typedef from referring to itself directly or indirectly, we can
-   * use these as sets of function type aliases that don't need to be expanded.
-   */
-  @override
-  bool isSubtypeOf(DartType type) {
-    // For non-function types, T <: S iff [_|_/dynamic]T << S.
-    return isMoreSpecificThan(type, true);
-  }
-
-  @override
-  bool isSupertypeOf(DartType type) => type.isSubtypeOf(this);
-
-  /**
-   * Create a new [TypeImpl] that is identical to [this] except that when
-   * visiting type parameters, function parameter types, and function return
-   * types, function types listed in [prune] will not be expanded.  This is
-   * used to avoid creating infinite types in the presence of circular
-   * typedefs.
-   *
-   * If [prune] is null, then [this] is returned unchanged.
-   *
-   * Only legal to call on a [TypeImpl] that is not already subject to pruning.
-   */
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune);
-
-  /**
-   * Return the type resulting from substituting the given [argumentTypes] for
-   * the given [parameterTypes] in this type.
-   *
-   * In all classes derived from [TypeImpl], a new optional argument
-   * [prune] is added.  If specified, it is a list of function typdefs
-   * which should not be expanded.  This is used to avoid creating infinite
-   * types in response to self-referential typedefs.
-   */
-  @override
-  DartType substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]);
-
-  @override
-  String toString() {
-    StringBuffer buffer = new StringBuffer();
-    appendTo(buffer);
-    return buffer.toString();
-  }
-
-  /**
-   * Return `true` if corresponding elements of the [first] and [second] lists
-   * of type arguments are all equal.
-   */
-  static bool equalArrays(List<DartType> first, List<DartType> second) {
-    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');
-        return second[i] == null;
-      } else if (second[i] == null) {
-        AnalysisEngine.instance.logger
-            .logInformation('Found null type argument in TypeImpl.equalArrays');
-        return false;
-      }
-      if (first[i] != second[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Return a list containing the results of using the given [argumentTypes] and
-   * [parameterTypes] to perform a substitution on all of the given [types].
-   *
-   * If [prune] is specified, it is a list of function typdefs which should not
-   * be expanded.  This is used to avoid creating infinite types in response to
-   * self-referential typedefs.
-   */
-  static List<DartType> substitute(List<DartType> types,
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) {
-    int length = types.length;
-    if (length == 0) {
-      return types;
-    }
-    List<DartType> newTypes = new List<DartType>(length);
-    for (int i = 0; i < length; i++) {
-      newTypes[i] = (types[i] as TypeImpl)
-          .substitute2(argumentTypes, parameterTypes, prune);
-    }
-    return newTypes;
-  }
-}
-
-/**
- * A concrete implementation of a [TypeParameterElement].
- */
-class TypeParameterElementImpl extends ElementImpl
-    implements 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.
-   */
-  DartType bound;
-
-  /**
-   * Initialize a newly created method element to have the given [name] and
-   * [offset].
-   */
-  TypeParameterElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created type parameter element to have the given [name].
-   */
-  TypeParameterElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  ElementKind get kind => ElementKind.TYPE_PARAMETER;
-
-  @override
-  accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write(displayName);
-    if (bound != null) {
-      buffer.write(" extends ");
-      buffer.write(bound);
-    }
-  }
-}
-
-/**
- * A concrete implementation of a [TypeParameterType].
- */
-class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
-  /**
-   * Initialize a newly created type parameter type to be declared by the given
-   * [element] and to have the given name.
-   */
-  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 isMoreSpecificThan(DartType s,
-      [bool withDynamic = false, Set<Element> visitedElements]) {
-    //
-    // 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;
-    }
-    //
-    // T is a type parameter and S is the upper bound of T.
-    //
-    TypeImpl bound = element.bound;
-    if (s == bound) {
-      return true;
-    }
-    //
-    // T is a type parameter and S is Object.
-    //
-    if (s.isObject) {
-      return true;
-    }
-    // We need upper bound to continue.
-    if (bound == null) {
-      return false;
-    }
-    //
-    // Transitivity: T << U and U << S.
-    //
-    // First check for infinite loops
-    if (element == null) {
-      return false;
-    }
-    if (visitedElements == null) {
-      visitedElements = new HashSet<Element>();
-    } else if (visitedElements.contains(element)) {
-      return false;
-    }
-    visitedElements.add(element);
-    try {
-      return bound.isMoreSpecificThan(s, withDynamic, visitedElements);
-    } finally {
-      visitedElements.remove(element);
-    }
-  }
-
-  @override
-  bool isSubtypeOf(DartType type) => isMoreSpecificThan(type, true);
-
-  @override
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
-
-  @override
-  DartType substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) {
-    int length = parameterTypes.length;
-    for (int i = 0; i < length; i++) {
-      if (parameterTypes[i] == this) {
-        return argumentTypes[i];
-      }
-    }
-    return this;
-  }
-
-  /**
-   * Return a list containing the type parameter types defined by the given
-   * array of type parameter elements ([typeParameters]).
-   */
-  static List<TypeParameterType> getTypes(
-      List<TypeParameterElement> typeParameters) {
-    int count = typeParameters.length;
-    if (count == 0) {
-      return TypeParameterType.EMPTY_LIST;
-    }
-    List<TypeParameterType> types = new List<TypeParameterType>(count);
-    for (int i = 0; i < count; i++) {
-      types[i] = typeParameters[i].type;
-    }
-    return types;
-  }
-}
-
-/**
- * The unique instance of the class `UndefinedTypeImpl` implements the type of
- * type names that couldn't be resolved.
- *
- * This class behaves like DynamicTypeImpl in almost every respect, to reduce
- * cascading errors.
- */
-class UndefinedTypeImpl extends TypeImpl {
-  /**
-   * The unique instance of this class.
-   */
-  static UndefinedTypeImpl _INSTANCE = new UndefinedTypeImpl._();
-
-  /**
-   * Return the unique instance of this class.
-   */
-  static UndefinedTypeImpl get instance => _INSTANCE;
-
-  /**
-   * Prevent the creation of instances of this class.
-   */
-  UndefinedTypeImpl._()
-      : super(DynamicElementImpl.instance, Keyword.DYNAMIC.syntax);
-
-  @override
-  int get hashCode => 1;
-
-  @override
-  bool get isDynamic => true;
-
-  @override
-  bool get isUndefined => true;
-
-  @override
-  bool operator ==(Object object) => identical(object, this);
-
-  @override
-  bool isMoreSpecificThan(DartType type,
-      [bool withDynamic = false, Set<Element> visitedElements]) {
-    // T is S
-    if (identical(this, type)) {
-      return true;
-    }
-    // else
-    return withDynamic;
-  }
-
-  @override
-  bool isSubtypeOf(DartType type) => true;
-
-  @override
-  bool isSupertypeOf(DartType type) => true;
-
-  @override
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
-
-  @override
-  DartType substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) {
-    int length = parameterTypes.length;
-    for (int i = 0; i < length; i++) {
-      if (parameterTypes[i] == this) {
-        return argumentTypes[i];
-      }
-    }
-    return this;
-  }
-}
-
-/**
- * A concrete implementation of a [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;
-
-  /**
-   * The URI that is specified by this directive.
-   */
-  String uri;
-
-  /**
-   * Initialize a newly created import element to have the given [name] and
-   * [offset]. The offset may be `-1` if the element is synthetic.
-   */
-  UriReferencedElementImpl(String name, int offset) : super(name, offset);
-}
-
-/**
- * A concrete implementation of a [VariableElement].
- */
-abstract class VariableElementImpl extends ElementImpl
-    implements VariableElement {
-  /**
-   * The declared type of this variable.
-   */
-  DartType type;
-
-  /**
-   * A synthetic function representing this variable's initializer, or `null` if
-   * this variable does not have an initializer.
-   */
-  FunctionElement _initializer;
-
-  /**
-   * Initialize a newly created variable element to have the given [name] and
-   * [offset].
-   */
-  VariableElementImpl(String name, int offset) : super(name, offset);
-
-  /**
-   * Initialize a newly created variable element to have the given [name].
-   */
-  VariableElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  /**
-   * Set whether this variable is const.
-   */
-  void set const3(bool isConst) {
-    setModifier(Modifier.CONST, isConst);
-  }
-
-  /**
-   * If this element represents a constant variable, and it has an initializer,
-   * a copy of the initializer for the constant.  Otherwise `null`.
-   *
-   * Note that in correct Dart code, all constant variables must have
-   * initializers.  However, analyzer also needs to handle incorrect Dart code,
-   * in which case there might be some constant variables that lack
-   * initializers.
-   */
-  Expression get constantInitializer => null;
-
-  @override
-  DartObject get constantValue => null;
-
-  /**
-   * Return the result of evaluating this variable's initializer as a
-   * compile-time constant expression, or `null` if this variable is not a
-   * 'const' variable, if it does not have an initializer, or if the compilation
-   * unit containing the variable has not been resolved.
-   */
-  EvaluationResultImpl get evaluationResult => null;
-
-  /**
-   * Set the result of evaluating this variable's initializer as a compile-time
-   * constant expression to the given [result].
-   */
-  void set evaluationResult(EvaluationResultImpl result) {
-    throw new IllegalStateException(
-        "Invalid attempt to set a compile-time constant result");
-  }
-
-  /**
-   * Set whether this variable is final.
-   */
-  void set final2(bool isFinal) {
-    setModifier(Modifier.FINAL, isFinal);
-  }
-
-  @override
-  bool get hasImplicitType => hasModifier(Modifier.IMPLICIT_TYPE);
-
-  /**
-   * Set whether this variable element has an implicit type.
-   */
-  void set hasImplicitType(bool hasImplicitType) {
-    setModifier(Modifier.IMPLICIT_TYPE, hasImplicitType);
-  }
-
-  @override
-  FunctionElement get initializer => _initializer;
-
-  /**
-   * Set the function representing this variable's initializer to the given
-   * [function].
-   */
-  void set initializer(FunctionElement function) {
-    if (function != null) {
-      (function as FunctionElementImpl).enclosingElement = this;
-    }
-    this._initializer = function;
-  }
-
-  @override
-  bool get isConst => hasModifier(Modifier.CONST);
-
-  @override
-  bool get isFinal => hasModifier(Modifier.FINAL);
-
-  @override
-  bool get isPotentiallyMutatedInClosure => false;
-
-  @override
-  bool get isPotentiallyMutatedInScope => false;
-
-  @override
-  bool get isStatic => hasModifier(Modifier.STATIC);
-
-  @override
-  void appendTo(StringBuffer buffer) {
-    buffer.write(type);
-    buffer.write(" ");
-    buffer.write(displayName);
-  }
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChild(_initializer, visitor);
-  }
-}
-
-/**
- * A variable element defined in a parameterized type where the values of the
- * type parameters are known.
- */
-abstract class VariableMember extends Member implements VariableElement {
-  @override
-  final DartType type;
-
-  /**
-   * Initialize a newly created element to represent a variable, based on the
-   * [baseElement], defined by the [definingType].
-   */
-  VariableMember(VariableElement baseElement, ParameterizedType definingType,
-      [DartType type])
-      : type = type ??
-            baseElement.type.substitute2(definingType.typeArguments,
-                TypeParameterTypeImpl.getTypes(definingType.typeParameters)),
-        super(baseElement, definingType);
-
-  // TODO(jmesserly): this is temporary to allow the ParameterMember subclass.
-  // Apparently mixins don't work with optional params.
-  VariableMember._(VariableElement baseElement, ParameterizedType definingType,
-      DartType type)
-      : this(baseElement, definingType, type);
-
-  @override
-  VariableElement get baseElement => super.baseElement as VariableElement;
-
-  @override
-  DartObject get constantValue => baseElement.constantValue;
-
-  @override
-  bool get hasImplicitType => baseElement.hasImplicitType;
-
-  @override
-  FunctionElement get initializer {
-    //
-    // Elements within this element should have type parameters substituted,
-    // just like this element.
-    //
-    throw new UnsupportedOperationException();
-    //    return getBaseElement().getInitializer();
-  }
-
-  @override
-  bool get isConst => baseElement.isConst;
-
-  @override
-  bool get isFinal => baseElement.isFinal;
-
-  @override
-  bool get isPotentiallyMutatedInClosure =>
-      baseElement.isPotentiallyMutatedInClosure;
-
-  @override
-  bool get isPotentiallyMutatedInScope =>
-      baseElement.isPotentiallyMutatedInScope;
-
-  @override
-  bool get isStatic => baseElement.isStatic;
-
-  @override
-  void visitChildren(ElementVisitor visitor) {
-    // TODO(brianwilkerson) We need to finish implementing the accessors used
-    // below so that we can safely invoke them.
-    super.visitChildren(visitor);
-    safelyVisitChild(baseElement.initializer, visitor);
-  }
-}
-
-/**
- * The type `void`.
- */
-abstract class VoidType implements DartType {
-  @override
-  VoidType substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes);
-}
-
-/**
- * A concrete implementation of a [VoidType].
- */
-class VoidTypeImpl extends TypeImpl implements VoidType {
-  /**
-   * The unique instance of this class.
-   */
-  static VoidTypeImpl _INSTANCE = new VoidTypeImpl();
-
-  /**
-   * Return the unique instance of this class.
-   */
-  static VoidTypeImpl get instance => _INSTANCE;
-
-  /**
-   * Prevent the creation of instances of this class.
-   */
-  VoidTypeImpl() : super(null, Keyword.VOID.syntax);
-
-  @override
-  int get hashCode => 2;
-
-  @override
-  bool get isVoid => true;
-
-  @override
-  bool operator ==(Object object) => identical(object, this);
-
-  @override
-  bool isMoreSpecificThan(DartType type,
-          [bool withDynamic = false, Set<Element> visitedElements]) =>
-      isSubtypeOf(type);
-
-  @override
-  bool isSubtypeOf(DartType type) {
-    // 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
-  TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
-
-  @override
-  VoidTypeImpl substitute2(
-          List<DartType> argumentTypes, List<DartType> parameterTypes,
-          [List<FunctionTypeAliasElement> prune]) =>
-      this;
-}
-
-/**
- * A visitor that visit all the elements recursively and fill the given [map].
- */
-class _BuildOffsetToElementMap extends GeneralizingElementVisitor {
-  final Map<int, Element> map;
-
-  _BuildOffsetToElementMap(this.map);
-
-  @override
-  void visitElement(Element element) {
-    int offset = element.nameOffset;
-    if (offset != -1) {
-      map[offset] = element;
-    }
-    super.visitElement(element);
-  }
-}
+export 'package:analyzer/src/dart/element/element.dart';
+export 'package:analyzer/src/dart/element/member.dart';
+export 'package:analyzer/src/dart/element/type.dart';