Roll Observatory packages and add a roll script

packages/analyzer/lib/src/generated/element.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// This code was auto-generated, is not intended to be edited, and is subject to
-// significant change. Please see the README file for more information.
-
 library engine.element;
 
 import 'dart:collection';
+import 'dart:math' show min;
 
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/task/model.dart'
     show AnalysisTarget, ConstantEvaluationTarget;
 
 import 'ast.dart';
 import 'constant.dart' show EvaluationResultImpl;
 import 'engine.dart' show AnalysisContext, AnalysisEngine, AnalysisException;
 import 'html.dart' show XmlAttributeNode, XmlTagNode;
@@ skipping 57 matching lines @@
   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;
+          [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;
+          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();
 
@@ skipping 434 matching lines @@
    * 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);
 
@@ skipping 580 matching lines @@
 
   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);
+      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);
+      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);
@@ skipping 1252 matching lines @@
    * Return the display name of this element, or `null` if this element does not
    * have a name.
    *
    * In most cases the name and the display name are the same. Differences
    * though are cases such as setters where the name of some setter `set f(x)`
    * is `f=`, instead of `f`.
    */
   String get displayName;
 
   /**
+   * Return the source range of the documentation comment for this element,
+   * or `null` if this element does not or cannot have a documentation.
+   */
+  SourceRange get docRange;
+
+  /**
    * Return the element that either physically or logically encloses this
    * element. This will be `null` if this element is a library because libraries
    * are the top-level elements in the model.
    */
   Element get enclosingElement;
 
   /**
    * The unique integer identifier of this element.
    */
   int get id;
@@ skipping 54 matching lines @@
    */
   List<ElementAnnotation> get metadata;
 
   /**
    * Return the name of this element, or `null` if this element does not have a
    * name.
    */
   String get name;
 
   /**
+   * Return the length of the name of this element in the file that contains the
+   * declaration of this element, or `0` if this element does not have a name.
+   */
+  int get nameLength;
+
+  /**
    * Return the offset of the name of this element in the file that contains the
    * declaration of this element, or `-1` if this element is synthetic, does not
    * have a name, or otherwise does not have an offset.
    */
   int get nameOffset;
 
   /**
+   * **DEPRECATED** Use `computeNode()` instead.
+   *
    * Return the resolved [AstNode] node that declares this element, or `null` if
    * this element is synthetic or isn't contained in a compilation unit, such as
    * a [LibraryElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    */
   @deprecated
@@ skipping 257 matching lines @@
    * 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;
   }
@@ skipping 69 matching lines @@
 
   @override
   String get name => _name;
 
   void set name(String name) {
     this._name = name;
     _cachedLocation = null;
     _cachedHashCode = null;
   }
 
-  /**
-   * The offset of the name of this element in the file that contains the
-   * declaration of this element.
-   */
+  @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;
@@ skipping 136 matching lines @@
    */
   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();
@@ skipping 413 matching lines @@
    */
   static const List<ExecutableElement> EMPTY_LIST = const <ExecutableElement>[];
 
   /**
    * Return a list containing all of the functions defined within this
    * executable element.
    */
   List<FunctionElement> get functions;
 
   /**
+   * Return `true` if this executable element did not have an explicit return
+   * type specified for it in the original source. Note that if there was no
+   * explicit return type, and if the element model is fully populated, then
+   * the [returnType] will not be `null`.
+   */
+  bool get hasImplicitReturnType;
+
+  /**
    * Return `true` if this executable element is abstract. Executable elements
    * are abstract if they are not external and have no body.
    */
   bool get isAbstract;
 
   /**
    * Return `true` if this executable element has body marked as being
    * asynchronous.
    */
   bool get isAsynchronous;
@@ skipping 43 matching lines @@
    */
   List<LocalVariableElement> get localVariables;
 
   /**
    * Return a list containing all of the parameters defined by this executable
    * element.
    */
   List<ParameterElement> get parameters;
 
   /**
-   * Return the return type defined by this executable element.
+   * Return the return type defined by this executable element. If the element
+   * model is fully populated, then the [returnType] will not be `null`, even
+   * if no return type was explicitly specified.
    */
   DartType get returnType;
 
   /**
    * Return the type of function defined by this executable element.
    */
   FunctionType get type;
 
   /**
    * Return a list containing all of the type parameters defined for this
@@ skipping 92 matching lines @@
   }
 
   /**
    * 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);
@@ skipping 166 matching lines @@
   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;
@@ skipping 183 matching lines @@
    * so parsing and resolving will be performed.
    */
   @override
   AstNode computeNode();
 }
 
 /**
  * A concrete implementation of a [FieldElement].
  */
 class FieldElementImpl extends PropertyInducingElementImpl
-    with PotentiallyConstVariableElement implements FieldElement {
+    with PotentiallyConstVariableElement
+    implements FieldElement {
   /**
    * An empty list of field elements.
    */
   @deprecated // Use FieldElement.EMPTY_LIST
   static const List<FieldElement> EMPTY_ARRAY = const <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
-  bool get isStatic => hasModifier(Modifier.STATIC);
-
-  @override
   ElementKind get kind => ElementKind.FIELD;
 
   /**
    * Set whether this field is static.
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
@@ skipping 94 matching lines @@
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
   @override
   PropertyAccessorElement get getter =>
       PropertyAccessorMember.from(baseElement.getter, definingType);
 
   @override
   bool get isEnumConstant => baseElement.isEnumConstant;
 
   @override
-  bool get isStatic => baseElement.isStatic;
-
-  @override
   DartType get propagatedType => substituteFor(baseElement.propagatedType);
 
   @override
   PropertyAccessorElement get setter =>
       PropertyAccessorMember.from(baseElement.setter, definingType);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 
   @override
@@ skipping 708 matching lines @@
     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);
+          type = (type as TypeImpl)
+              .substitute2(typeArguments, typeParameters, newPrune);
         } else {
           type = (type as TypeImpl).pruned(newPrune);
         }
         namedParameterTypes[parameter.name] = type;
       }
     }
     return namedParameterTypes;
   }
 
   /**
@@ skipping 24 matching lines @@
       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);
+          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);
+          type = (type as TypeImpl)
+              .substitute2(typeArguments, typeParameters, newPrune);
         } else {
           type = (type as TypeImpl).pruned(newPrune);
         }
         types.add(type);
       }
     }
     return types;
   }
 
   @override
@@ skipping 161 matching lines @@
       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)) {
+          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)) {
+        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)) {
+          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)) {
+          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);
   }
@@ skipping 1331 matching lines @@
       //
       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)) {
+          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)) {
+        if ((interfaceType as InterfaceTypeImpl)
+            .isMoreSpecificThan(type, withDynamic, visitedElements)) {
           return true;
         }
       }
       for (InterfaceType mixinType in mixins) {
-        if ((mixinType as InterfaceTypeImpl).isMoreSpecificThan(
-            type, withDynamic, visitedElements)) {
+        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)) {
@@ skipping 584 matching lines @@
    */
   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)
+  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);
+      : 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) {
@@ skipping 125 matching lines @@
     }
     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 {
     if (_loadLibraryFunction == null) {
       FunctionElementImpl function =
           new FunctionElementImpl(FunctionElement.LOAD_LIBRARY_NAME, -1);
       function.synthetic = true;
       function.enclosingElement = this;
       function.returnType = loadLibraryReturnType;
       function.type = new FunctionTypeImpl(function);
       _loadLibraryFunction = function;
@@ skipping 166 matching lines @@
   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);
+        (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);
+          (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 recusion in the case of mutually dependent libraries.
    */
@@ skipping 73 matching lines @@
    * so parsing and resolving will be performed.
    */
   @override
   VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [LocalVariableElement].
  */
 class LocalVariableElementImpl extends VariableElementImpl
-    with PotentiallyConstVariableElement implements LocalVariableElement {
+    with PotentiallyConstVariableElement
+    implements LocalVariableElement {
   /**
    * An empty list of field elements.
    */
   @deprecated // Use LocalVariableElement.EMPTY_LIST
   static const List<LocalVariableElement> EMPTY_ARRAY =
       const <LocalVariableElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
@@ skipping 111 matching lines @@
   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;
@@ skipping 13 matching lines @@
   @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;
 
   @deprecated
   @override
   AstNode get node => computeNode();
 
   @override
   Source get source => _baseElement.source;
 
   @override
@@ skipping 317 matching lines @@
   static const Modifier GETTER = const Modifier('GETTER', 9);
 
   /**
    * A flag used for libraries indicating that the defining compilation unit
    * contains at least one import directive whose URI uses the "dart-ext"
    * scheme.
    */
   static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 10);
 
   /**
+   * Indicates that the associated element did not have an explicit type
+   * associated with it. If the element is an [ExecutableElement], then the
+   * type being referred to is the return type.
+   */
+  static const Modifier IMPLICIT_TYPE = const Modifier('IMPLICIT_TYPE', 11);
+
+  /**
    * Indicates that a class can validly be used as a mixin.
    */
-  static const Modifier MIXIN = const Modifier('MIXIN', 11);
+  static const Modifier MIXIN = const Modifier('MIXIN', 12);
 
   /**
    * Indicates that a class is a mixin application.
    */
   static const Modifier MIXIN_APPLICATION =
-      const Modifier('MIXIN_APPLICATION', 12);
+      const Modifier('MIXIN_APPLICATION', 13);
 
   /**
    * Indicates that the value of a parameter or local variable might be mutated
    * within the context.
    */
   static const Modifier POTENTIALLY_MUTATED_IN_CONTEXT =
-      const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 13);
+      const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 14);
 
   /**
    * Indicates that the value of a parameter or local variable might be mutated
    * within the scope.
    */
   static const Modifier POTENTIALLY_MUTATED_IN_SCOPE =
-      const Modifier('POTENTIALLY_MUTATED_IN_SCOPE', 14);
+      const Modifier('POTENTIALLY_MUTATED_IN_SCOPE', 15);
 
   /**
    * Indicates that a class contains an explicit reference to 'super'.
    */
   static const Modifier REFERENCES_SUPER =
-      const Modifier('REFERENCES_SUPER', 15);
+      const Modifier('REFERENCES_SUPER', 16);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static const Modifier SETTER = const Modifier('SETTER', 16);
+  static const Modifier SETTER = const Modifier('SETTER', 17);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static const Modifier STATIC = const Modifier('STATIC', 17);
+  static const Modifier STATIC = const Modifier('STATIC', 18);
 
   /**
    * Indicates that the element does not appear in the source code but was
    * implicitly created. For example, if a class does not define any
    * constructors, an implicit zero-argument constructor will be created and it
    * will be marked as being synthetic.
    */
-  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 18);
+  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 19);
 
   static const List<Modifier> values = const [
     ABSTRACT,
     ASYNCHRONOUS,
     CONST,
     DEFERRED,
     ENUM,
     EXTERNAL,
     FACTORY,
     FINAL,
     GENERATOR,
     GETTER,
     HAS_EXT_URI,
+    IMPLICIT_TYPE,
     MIXIN,
     MIXIN_APPLICATION,
     POTENTIALLY_MUTATED_IN_CONTEXT,
     POTENTIALLY_MUTATED_IN_SCOPE,
     REFERENCES_SUPER,
     SETTER,
     STATIC,
     SYNTHETIC
   ];
 
@@ skipping 49 matching lines @@
    * 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 {
@@ skipping 19 matching lines @@
   @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;
 
   @deprecated
   @override
   AstNode get node => null;
 
   @override
   Source get source => null;
 
   @override
@@ skipping 212 matching lines @@
    */
   List<ParameterElement> get parameters;
 
   /**
    * Return a list containing all of the type parameters defined by this
    * parameter. A parameter will only define other parameters if it is a
    * function typed parameter.
    */
   List<TypeParameterElement> get typeParameters;
 
+  /**
+   * Append the type, name and possibly the default value of this parameter to
+   * the given [buffer].
+   */
+  void appendToWithoutDelimiters(StringBuffer buffer);
+
   @override
   FormalParameter computeNode();
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
-    with PotentiallyConstVariableElement implements ParameterElement {
+    with ParameterElementMixin, PotentiallyConstVariableElement
+    implements ParameterElement {
   /**
    * An empty list of parameter elements.
    */
   @deprecated // Use ParameterElement.EMPTY_LIST
   static const List<ParameterElement> EMPTY_ARRAY = const <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.
@@ skipping 114 matching lines @@
         left = "[";
         right = "]";
       } else if (parameterKind == ParameterKind.REQUIRED) {}
       break;
     }
     buffer.write(left);
     appendToWithoutDelimiters(buffer);
     buffer.write(right);
   }
 
-  /**
-   * Append the type and name of this parameter to the given [buffer].
-   */
-  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);
-    }
-  }
-
   @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;
       }
@@ skipping 25 matching lines @@
   }
 
   @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 type with type parameters, such as a class or function type alias.
  */
 abstract class ParameterizedType implements DartType {
   /**
    * Return a list containing the actual types of the type arguments. If this
    * type's element does not have type parameters, then the array should be
    * empty (although it is possible for type arguments to be erroneously
    * declared). If the element has type parameters and the actual type does not
    * explicitly include argument values, then the type "dynamic" will be
    * automatically provided.
    */
   List<DartType> get typeArguments;
 
   /**
    * Return a list containing all of the type parameters declared for this type.
    */
   List<TypeParameterElement> get typeParameters;
 }
 
 /**
  * A parameter element defined in a parameterized type where the values of the
  * type parameters are known.
  */
-class ParameterMember extends VariableMember implements ParameterElement {
+class ParameterMember extends VariableMember
+    with ParameterElementMixin
+    implements ParameterElement {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
    */
   ParameterMember(ParameterElement baseElement, ParameterizedType definingType)
       : super(baseElement, definingType);
 
   @override
   ParameterElement get baseElement => super.baseElement as ParameterElement;
 
@@ skipping 578 matching lines @@
       const <PropertyInducingElement>[];
 
   /**
    * Return the getter associated with this variable. If this variable was
    * explicitly defined (is not synthetic) then the getter associated with it
    * will be synthetic.
    */
   PropertyAccessorElement get getter;
 
   /**
-   * Return `true` if this element is a static element. A static element is an
-   * element that is not associated with a particular instance, but rather with
-   * an entire library or class.
-   */
-  bool get isStatic;
-
-  /**
    * Return the propagated type of this variable, or `null` if type propagation
    * has not been performed, for example because the variable is not final.
    */
   DartType get propagatedType;
 
   /**
    * Return the setter associated with this variable, or `null` if the variable
    * is effectively `final` and therefore does not have a setter associated with
    * it. (This can happen either because the variable is explicitly defined as
    * being `final` or because the variable is induced by an explicit getter that
@@ skipping 342 matching lines @@
       const <TopLevelVariableElement>[];
 
   @override
   VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [TopLevelVariableElement].
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl
-    with PotentiallyConstVariableElement implements TopLevelVariableElement {
+    with PotentiallyConstVariableElement
+    implements TopLevelVariableElement {
   /**
    * An empty list of top-level variable elements.
    */
   @deprecated // Use TopLevelVariableElement.EMPTY_LIST
   static const List<TopLevelVariableElement> EMPTY_ARRAY =
       const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the
    * given [name] and [offset].
@@ skipping 222 matching lines @@
    */
   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);
+      newTypes[i] = (types[i] as TypeImpl)
+          .substitute2(argumentTypes, parameterTypes, prune);
     }
     return newTypes;
   }
 }
 
 /**
  * A type parameter.
  */
-abstract class TypeParameterElement implements Element {
+abstract class TypeParameterElement implements TypeDefiningElement {
   /**
    * An empty list of type parameter elements.
    */
   static const List<TypeParameterElement> EMPTY_LIST =
       const <TypeParameterElement>[];
 
   /**
    * Return the type representing the bound associated with this parameter, or
    * `null` if this parameter does not have an explicit bound.
    */
@@ skipping 319 matching lines @@
 /**
  * A variable. There are concrete subclasses for different kinds of variables.
  */
 abstract class VariableElement implements Element, ConstantEvaluationTarget {
   /**
    * An empty list of variable elements.
    */
   static const List<VariableElement> EMPTY_LIST = const <VariableElement>[];
 
   /**
+   * Return `true` if this variable element did not have an explicit type
+   * specified for it.
+   */
+  bool get hasImplicitType;
+
+  /**
    * Return a synthetic function representing this variable's initializer, or
    * `null` if this variable does not have an initializer. The function will
    * have no parameters. The return type of the function will be the
    * compile-time type of the initialization expression.
    */
   FunctionElement get initializer;
 
   /**
    * Return `true` if this variable was declared with the 'const' modifier.
    */
@@ skipping 16 matching lines @@
 
   /**
    * Return `true` if this variable is potentially mutated somewhere in its
    * scope. This information is only available for local variables (including
    * parameters) and only after the compilation unit containing the variable has
    * been resolved.
    */
   bool get isPotentiallyMutatedInScope;
 
   /**
+   * Return `true` if this element is a static variable, as per section 8 of the
+   * Dart Language Specification:
+   *
+   * > A static variable is a variable that is not associated with a particular
+   * > instance, but rather with an entire library or class. Static variables
+   * > include library variables and class variables. Class variables are
+   * > variables whose declaration is immediately nested inside a class
+   * > declaration and includes the modifier static. A library variable is
+   * > implicitly static.
+   */
+  bool get isStatic;
+
+  /**
    * Return the declared type of this variable, or `null` if the variable did
    * not have a declared type (such as if it was declared using the keyword
    * 'var').
    */
   DartType get type;
 }
 
 /**
  * A concrete implementation of a [VariableElement].
  */
@@ skipping 52 matching lines @@
   }
 
   /**
    * 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 {
   /**
    * Initialize a newly created element to represent a constructor, based on the
    * [baseElement], defined by the [definingType].
    */
   VariableMember(VariableElement baseElement, ParameterizedType definingType)
       : super(baseElement, definingType);
 
   @override
   VariableElement get baseElement => super.baseElement as VariableElement;
 
   @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
   DartType get type => substituteFor(baseElement.type);
 
   @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);
   }
 }
@@ skipping 47 matching lines @@
     // 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;
+          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);
   }
 }