Update and analyzer snapshot with AST -> Ast rename.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart';
 import 'sdk.dart' show DartSdk;
 import 'html.dart' show XmlAttributeNode, XmlTagNode;
 import 'engine.dart' show AnalysisContext;
 import 'constant.dart' show EvaluationResultImpl;
 import 'utilities_dart.dart';
 
 /**
  * The interface `ClassElement` defines the behavior of elements that represent a class.
- *
- * @coverage dart.engine.element
  */
 abstract class ClassElement implements Element {
   /**
    * Return an array containing all of the accessors (getters and setters) declared in this class.
    *
    * @return the accessors declared in this class
    */
   List<PropertyAccessorElement> get accessors;
 
   /**
@@ skipping 209 matching lines @@
    * @return `true` if this class can validly be used as a mixin
    */
   bool get isValidMixin;
 
   /**
    * Return the element representing the getter that results from looking up the given getter in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library);
 
   /**
    * Return the element representing the method that results from looking up the given method in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect to library
    * <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param methodName the name of the method being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given method in this class with respect to the given
    *         library
    */
   MethodElement lookUpMethod(String methodName, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the given setter in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.16:
    * <blockquote> The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param setterName the name of the setter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given setter in this class with respect to the given
    *         library
    */
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library);
 }
 
@@ skipping 14 matching lines @@
    * not associated with a particular instance, but rather with an entire library or class.
    *
    * @return `true` if this executable element is a static element
    */
   bool get isStatic;
 }
 
 /**
  * The interface `CompilationUnitElement` defines the behavior of elements representing a
  * compilation unit.
- *
- * @coverage dart.engine.element
  */
 abstract class CompilationUnitElement implements Element, UriReferencedElement {
   /**
    * Return an array containing all of the top-level accessors (getters and setters) contained in
    * this compilation unit.
    *
    * @return the top-level accessors contained in this compilation unit
    */
   List<PropertyAccessorElement> get accessors;
 
@@ skipping 57 matching lines @@
    * Return an array containing all of the classes contained in this compilation unit.
    *
    * @return the classes contained in this compilation unit
    */
   List<ClassElement> get types;
 }
 
 /**
  * The interface `ConstructorElement` defines the behavior of elements representing a
  * constructor or a factory method defined within a type.
- *
- * @coverage dart.engine.element
  */
 abstract class ConstructorElement implements ClassMemberElement, ExecutableElement {
   /**
    * Return the resolved [ConstructorDeclaration] node that declares this
    * [ConstructorElement] .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [ConstructorDeclaration], not `null`.
@@ skipping 34 matching lines @@
 
 /**
  * The interface `Element` defines the behavior common to all of the elements in the element
  * model. Generally speaking, the element model is a semantic model of the program that represents
  * things that are declared with a name and hence can be referenced elsewhere in the code.
  *
  * There are two exceptions to the general case. First, there are elements in the element model that
  * are created for the convenience of various kinds of analysis but that do not have any
  * corresponding declaration within the source code. Such elements are marked as being
  * <i>synthetic</i>. Examples of synthetic elements include
- *
  * * default constructors in classes that do not define any explicit constructors,
  * * getters and setters that are induced by explicit field declarations,
  * * fields that are induced by explicit declarations of getters and setters, and
  * * functions representing the initialization expression for a variable.
  *
- *
  * Second, there are elements in the element model that do not have a name. These correspond to
  * unnamed functions and exist in order to more accurately represent the semantic structure of the
  * program.
- *
- * @coverage dart.engine.element
  */
 abstract class Element {
   /**
    * An Unicode right arrow.
    */
   static final String RIGHT_ARROW = " \u2192 ";
 
   /**
    * A comparator that can be used to sort elements by their name offset. Elements with a smaller
    * offset will be sorted to be before elements with a larger name offset.
@@ skipping 98 matching lines @@
   /**
    * 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.
    *
    * @return the offset of the name of this element
    */
   int get nameOffset;
 
   /**
-   * Return the resolved [ASTNode] node that declares this [Element].
+   * Return the resolved [AstNode] node that declares this [Element].
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
-   * @return the resolved [ASTNode], maybe `null` if [Element] is synthetic or
+   * @return the resolved [AstNode], maybe `null` if [Element] is synthetic or
    *         isn't contained in a compilation unit, such as a [LibraryElement].
    */
-  ASTNode get node;
+  AstNode get node;
 
   /**
    * Return the source that contains this element, or `null` if this element is not contained
    * in a source.
    *
    * @return the source that contains this element
    */
   Source get source;
 
   /**
@@ skipping 62 matching lines @@
    * the order in which the children will be visited.
    *
    * @param visitor the visitor that will be used to visit the children of this element
    */
   void visitChildren(ElementVisitor visitor);
 }
 
 /**
  * The interface `ElementAnnotation` defines the behavior of objects representing a single
  * annotation associated with an element.
- *
- * @coverage dart.engine.element
  */
 abstract class ElementAnnotation {
   /**
    * Return the element representing the field, variable, or const constructor being used as an
    * annotation.
    *
    * @return the field, variable, or constructor being used as an annotation
    */
   Element get element;
 
@@ skipping 18 matching lines @@
    * object.
    *
    * @return `true` if this annotation marks the associated class as implementing a proxy
    *         object
    */
   bool get isProxy;
 }
 
 /**
  * The enumeration `ElementKind` defines the various kinds of elements in the element model.
- *
- * @coverage dart.engine.element
  */
 class ElementKind extends Enum<ElementKind> {
   static final ElementKind ANGULAR_FILTER = new ElementKind('ANGULAR_FILTER', 0, "Angular filter");
 
   static final ElementKind ANGULAR_COMPONENT = new ElementKind('ANGULAR_COMPONENT', 1, "Angular component");
 
   static final ElementKind ANGULAR_CONTROLLER = new ElementKind('ANGULAR_CONTROLLER', 2, "Angular controller");
 
   static final ElementKind ANGULAR_DIRECTIVE = new ElementKind('ANGULAR_DIRECTIVE', 3, "Angular directive");
 
@@ skipping 113 matching lines @@
    * Initialize a newly created element kind to have the given display name.
    *
    * @param displayName the name displayed in the UI for this kind of element
    */
   ElementKind(String name, int ordinal, this.displayName) : super(name, ordinal);
 }
 
 /**
  * The interface `ElementLocation` defines the behavior of objects that represent the location
  * of an element within the element model.
- *
- * @coverage dart.engine.element
  */
 abstract class ElementLocation {
   /**
    * Return an encoded representation of this location that can be used to create a location that is
    * equal to this location.
    *
    * @return an encoded representation of this location
    */
   String get encoding;
 }
 
 /**
  * The interface `ElementVisitor` defines the behavior of objects that can be used to visit an
  * element structure.
- *
- * @coverage dart.engine.element
  */
 abstract class ElementVisitor<R> {
   R visitAngularComponentElement(AngularComponentElement element);
 
   R visitAngularControllerElement(AngularControllerElement element);
 
   R visitAngularDirectiveElement(AngularDirectiveElement element);
 
   R visitAngularFilterElement(AngularFilterElement element);
 
@@ skipping 46 matching lines @@
   R visitPropertyAccessorElement(PropertyAccessorElement element);
 
   R visitTopLevelVariableElement(TopLevelVariableElement element);
 
   R visitTypeParameterElement(TypeParameterElement element);
 }
 
 /**
  * The interface `EmbeddedHtmlScriptElement` defines the behavior of elements representing a
  * script tag in an HTML file having content that defines a Dart library.
- *
- * @coverage dart.engine.element
  */
 abstract class EmbeddedHtmlScriptElement implements HtmlScriptElement {
   /**
    * Return the library element defined by the content of the script tag.
    *
    * @return the library element (not `null`)
    */
   LibraryElement get scriptLibrary;
 }
 
 /**
  * The interface `ExecutableElement` defines the behavior of elements representing an
  * executable object, including functions, methods, constructors, getters, and setters.
- *
- * @coverage dart.engine.element
  */
 abstract class ExecutableElement implements Element {
   /**
    * Return an array containing all of the functions defined within this executable element.
    *
    * @return the functions defined within this executable element
    */
   List<FunctionElement> get functions;
 
   /**
@@ skipping 45 matching lines @@
    * not associated with a particular instance, but rather with an entire library or class.
    *
    * @return `true` if this executable element is a static element
    */
   bool get isStatic;
 }
 
 /**
  * The interface `ExportElement` defines the behavior of objects representing information
  * about a single export directive within a library.
- *
- * @coverage dart.engine.element
  */
 abstract class ExportElement implements Element, UriReferencedElement {
   /**
    * An empty array of export elements.
    */
   static final List<ExportElement> EMPTY_ARRAY = new List<ExportElement>(0);
 
   /**
    * Return an array containing the combinators that were specified as part of the export directive
    * in the order in which they were specified.
    *
    * @return the combinators specified in the export directive
    */
   List<NamespaceCombinator> get combinators;
 
   /**
    * Return the library that is exported from this library by this export directive.
    *
    * @return the library that is exported from this library
    */
   LibraryElement get exportedLibrary;
 }
 
 /**
  * The interface `ExternalHtmlScriptElement` defines the behavior of elements representing a
  * script tag in an HTML file having a `source` attribute that references a Dart library
  * source file.
- *
- * @coverage dart.engine.element
  */
 abstract class ExternalHtmlScriptElement implements HtmlScriptElement {
   /**
    * Return the source referenced by this element, or `null` if this element does not
    * reference a Dart library source file.
    *
    * @return the source for the external Dart library
    */
   Source get scriptSource;
 }
 
 /**
  * The interface `FieldElement` defines the behavior of elements representing a field defined
  * within a type.
- *
- * @coverage dart.engine.element
  */
 abstract class FieldElement implements ClassMemberElement, PropertyInducingElement {
 }
 
 /**
  * The interface `FieldFormalParameterElement` defines the behavior of elements representing a
  * field formal parameter defined within a constructor element.
  */
 abstract class FieldFormalParameterElement implements ParameterElement {
   /**
    * Return the field element associated with this field formal parameter, or `null` if the
    * parameter references a field that doesn't exist.
    *
    * @return the field element associated with this field formal parameter
    */
   FieldElement get field;
 }
 
 /**
  * The interface `FunctionElement` defines the behavior of elements representing a function.
- *
- * @coverage dart.engine.element
  */
 abstract class FunctionElement implements ExecutableElement, LocalElement {
   /**
    * Return the resolved [FunctionDeclaration] node that declares this [FunctionElement]
    * .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [FunctionDeclaration], not `null`.
    */
   FunctionDeclaration get node;
 }
 
 /**
  * The interface `FunctionTypeAliasElement` defines the behavior of elements representing a
  * function type alias (`typedef`).
- *
- * @coverage dart.engine.element
  */
 abstract class FunctionTypeAliasElement implements Element {
   /**
    * Return the compilation unit in which this type alias is defined.
    *
    * @return the compilation unit in which this type alias is defined
    */
   CompilationUnitElement get enclosingElement;
 
   /**
@@ skipping 32 matching lines @@
    * Return an array containing all of the type parameters defined for this type.
    *
    * @return the type parameters defined for this type
    */
   List<TypeParameterElement> get typeParameters;
 }
 
 /**
  * The interface `HideElementCombinator` defines the behavior of combinators that cause some
  * of the names in a namespace to be hidden when being imported.
- *
- * @coverage dart.engine.element
  */
 abstract class HideElementCombinator implements NamespaceCombinator {
   /**
    * Return an array containing the names that are not to be made visible in the importing library
    * even if they are defined in the imported library.
    *
    * @return the names from the imported library that are hidden from the importing library
    */
   List<String> get hiddenNames;
 }
 
 /**
  * The interface `HtmlElement` defines the behavior of elements representing an HTML file.
- *
- * @coverage dart.engine.element
  */
 abstract class HtmlElement implements Element {
   /**
    * Return the [CompilationUnitElement] associated with this Angular HTML file, maybe
    * `null` if not an Angular file.
    */
   CompilationUnitElement get angularCompilationUnit;
 
   /**
    * Return an array containing all of the script elements contained in the HTML file. This includes
    * scripts with libraries that are defined by the content of a script tag as well as libraries
    * that are referenced in the {@core source} attribute of a script tag.
    *
    * @return the script elements in the HTML file (not `null`, contains no `null`s)
    */
   List<HtmlScriptElement> get scripts;
 }
 
 /**
  * The interface `HtmlScriptElement` defines the behavior of elements representing a script
  * tag in an HTML file.
  *
  * @see EmbeddedHtmlScriptElement
  * @see ExternalHtmlScriptElement
- * @coverage dart.engine.element
  */
 abstract class HtmlScriptElement implements Element {
 }
 
 /**
  * The interface `ImportElement` defines the behavior of objects representing information
  * about a single import directive within a library.
- *
- * @coverage dart.engine.element
  */
 abstract class ImportElement implements Element, UriReferencedElement {
   /**
    * An empty array of import elements.
    */
   static final List<ImportElement> EMPTY_ARRAY = new List<ImportElement>(0);
 
   /**
    * Return an array containing the combinators that were specified as part of the import directive
    * in the order in which they were specified.
@@ skipping 31 matching lines @@
    * or `-1` for synthetic import.
    *
    * @return the offset of the character just past the node's URI
    */
   int get uriEnd;
 }
 
 /**
  * The interface `LabelElement` defines the behavior of elements representing a label
  * associated with a statement.
- *
- * @coverage dart.engine.element
  */
 abstract class LabelElement implements Element {
   /**
    * Return the executable element in which this label is defined.
    *
    * @return the executable element in which this label is defined
    */
   ExecutableElement get enclosingElement;
 }
 
 /**
  * The interface `LibraryElement` defines the behavior of elements representing a library.
- *
- * @coverage dart.engine.element
  */
 abstract class LibraryElement implements Element {
   /**
    * Return the compilation unit that defines this library.
    *
    * @return the compilation unit that defines this library
    */
   CompilationUnitElement get definingCompilationUnit;
 
   /**
@@ skipping 117 matching lines @@
    *
    * @param timeStamp the time stamp to compare against
    * @return `true` if this library is up to date with respect to the given time stamp
    */
   bool isUpToDate2(int timeStamp);
 }
 
 /**
  * The interface `LocalElement` defines the behavior of elements that can be (but are not
  * required to be) defined within a method or function (an [ExecutableElement]).
- *
- * @coverage dart.engine.element
  */
 abstract class LocalElement implements Element {
   /**
    * Return a source range that covers the approximate portion of the source in which the name of
    * this element is visible, or `null` if there is no single range of characters within which
    * the element name is visible.
-   *
    * * For a local variable, this includes everything from the end of the variable's initializer
    * to the end of the block that encloses the variable declaration.
    * * For a parameter, this includes the body of the method or function that declares the
    * parameter.
    * * For a local function, this includes everything from the beginning of the function's body to
    * the end of the block that encloses the function declaration.
    * * For top-level functions, `null` will be returned because they are potentially visible
    * in multiple sources.
    *
-   *
    * @return the range of characters in which the name of this element is visible
    */
   SourceRange get visibleRange;
 }
 
 /**
  * The interface `LocalVariableElement` defines the behavior common to elements that represent
  * a local variable.
- *
- * @coverage dart.engine.element
  */
 abstract class LocalVariableElement implements LocalElement, VariableElement {
   /**
    * Return an array containing all of the toolkit specific objects attached to this variable.
    *
    * @return the toolkit objects attached to this variable
    */
   List<ToolkitObjectElement> get toolkitObjects;
 }
 
 /**
  * The interface `MethodElement` defines the behavior of elements that represent a method
  * defined within a type.
- *
- * @coverage dart.engine.element
  */
 abstract class MethodElement implements ClassMemberElement, ExecutableElement {
   /**
    * Return the resolved [MethodDeclaration] node that declares this [MethodElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [MethodDeclaration], not `null`.
    */
   MethodDeclaration get node;
 
   /**
    * Return `true` if this method is abstract. Methods are abstract if they are not external
    * and have no body.
    *
    * @return `true` if this method is abstract
    */
   bool get isAbstract;
 }
 
 /**
  * The interface `MultiplyDefinedElement` defines the behavior of pseudo-elements that
  * represent multiple elements defined within a single scope that have the same name. This situation
  * is not allowed by the language, so objects implementing this interface always represent an error.
  * As a result, most of the normal operations on elements do not make sense and will return useless
  * results.
- *
- * @coverage dart.engine.element
  */
 abstract class MultiplyDefinedElement implements Element {
   /**
    * Return an array containing all of the elements that were defined within the scope to have the
    * same name.
    *
    * @return the elements that were defined with the same name
    */
   List<Element> get conflictingElements;
 
   /**
    * Return the type of this element as the dynamic type.
    *
    * @return the type of this element as the dynamic type
    */
   Type2 get type;
 }
 
 /**
  * The interface [MultiplyInheritedExecutableElement] defines all of the behavior of an
  * [ExecutableElement], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
- *
- * @coverage dart.engine.element
  */
 abstract class MultiplyInheritedExecutableElement implements ExecutableElement {
   /**
    * Return an array containing all of the executable elements defined within this executable
    * element.
    *
    * @return the elements defined within this executable element
    */
   List<ExecutableElement> get inheritedElements;
 }
 
 /**
  * The interface `NamespaceCombinator` defines the behavior common to objects that control how
  * namespaces are combined.
- *
- * @coverage dart.engine.element
  */
 abstract class NamespaceCombinator {
   /**
    * An empty array of namespace combinators.
    */
   static final List<NamespaceCombinator> EMPTY_ARRAY = new List<NamespaceCombinator>(0);
 }
 
 /**
  * The interface `ParameterElement` defines the behavior of elements representing a parameter
  * defined within an executable element.
- *
- * @coverage dart.engine.element
  */
 abstract class ParameterElement implements LocalElement, VariableElement {
   /**
    * Return a source range that covers the portion of the source in which the default value for this
    * parameter is specified, or `null` if there is no default value.
    *
    * @return the range of characters in which the default value of this parameter is specified
    */
   SourceRange get defaultValueRange;
 
@@ skipping 16 matching lines @@
    * Return `true` if this parameter is an initializing formal parameter.
    *
    * @return `true` if this parameter is an initializing formal parameter
    */
   bool get isInitializingFormal;
 }
 
 /**
  * The interface `PrefixElement` defines the behavior common to elements that represent a
  * prefix used to import one or more libraries into another library.
- *
- * @coverage dart.engine.element
  */
 abstract class PrefixElement implements Element {
   /**
    * Return the library into which other libraries are imported using this prefix.
    *
    * @return the library into which other libraries are imported using this prefix
    */
   LibraryElement get enclosingElement;
 
   /**
    * Return an array containing all of the libraries that are imported using this prefix.
    *
    * @return the libraries that are imported using this prefix
    */
   List<LibraryElement> get importedLibraries;
 }
 
 /**
  * The interface `PropertyAccessorElement` defines the behavior of elements representing a
  * getter or a setter. Note that explicitly defined property accessors implicitly define a synthetic
  * field. Symmetrically, synthetic accessors are implicitly created for explicitly defined fields.
  * The following rules apply:
- *
  * * Every explicit field is represented by a non-synthetic [FieldElement].
  * * Every explicit field induces a getter and possibly a setter, both of which are represented by
  * synthetic [PropertyAccessorElement]s.
  * * Every explicit getter or setter is represented by a non-synthetic
  * [PropertyAccessorElement].
  * * Every explicit getter or setter (or pair thereof if they have the same name) induces a field
  * that is represented by a synthetic [FieldElement].
- *
- *
- * @coverage dart.engine.element
  */
 abstract class PropertyAccessorElement implements ExecutableElement {
   /**
    * Return the accessor representing the getter that corresponds to (has the same name as) this
    * setter, or `null` if this accessor is not a setter or if there is no corresponding
    * getter.
    *
    * @return the getter that corresponds to this setter
    */
   PropertyAccessorElement get correspondingGetter;
@@ skipping 37 matching lines @@
    */
   bool get isSetter;
 }
 
 /**
  * The interface `PropertyInducingElement` defines the behavior of elements representing a
  * variable that has an associated getter and possibly a setter. Note that explicitly defined
  * variables implicitly define a synthetic getter and that non-`final` explicitly defined
  * variables implicitly define a synthetic setter. Symmetrically, synthetic fields are implicitly
  * created for explicitly defined getters and setters. The following rules apply:
- *
  * * Every explicit variable is represented by a non-synthetic [PropertyInducingElement].
  * * Every explicit variable induces a getter and possibly a setter, both of which are represented
  * by synthetic [PropertyAccessorElement]s.
  * * Every explicit getter or setter is represented by a non-synthetic
  * [PropertyAccessorElement].
  * * Every explicit getter or setter (or pair thereof if they have the same name) induces a
  * variable that is represented by a synthetic [PropertyInducingElement].
- *
- *
- * @coverage dart.engine.element
  */
 abstract class PropertyInducingElement implements VariableElement {
   /**
    * 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.
    *
    * @return the getter associated with this variable
    */
   PropertyAccessorElement get getter;
 
@@ skipping 13 matching lines @@
    * not associated with a particular instance, but rather with an entire library or class.
    *
    * @return `true` if this executable element is a static element
    */
   bool get isStatic;
 }
 
 /**
  * The interface `ShowElementCombinator` defines the behavior of combinators that cause some
  * of the names in a namespace to be visible (and the rest hidden) when being imported.
- *
- * @coverage dart.engine.element
  */
 abstract class ShowElementCombinator implements NamespaceCombinator {
   /**
    * Return the offset of the character immediately following the last character of this node.
    *
    * @return the offset of the character just past this node
    */
   int get end;
 
   /**
    * Return the offset of the 'show' keyword of this element.
    *
    * @return the offset of the 'show' keyword of this element
    */
   int get offset;
 
   /**
    * Return an array containing the names that are to be made visible in the importing library if
    * they are defined in the imported library.
    *
    * @return the names from the imported library that are visible in the importing library
    */
   List<String> get shownNames;
 }
 
 /**
  * The interface `ToolkitObjectElement` defines the behavior of elements that represent a
  * toolkit specific object, such as Angular controller or component. These elements are not based on
  * the Dart syntax, but on some semantic agreement, such as a special annotation.
- *
- * @coverage dart.engine.element
  */
 abstract class ToolkitObjectElement implements Element {
   /**
    * An empty array of toolkit object elements.
    */
   static final List<ToolkitObjectElement> EMPTY_ARRAY = new List<ToolkitObjectElement>(0);
 }
 
 /**
  * The interface `TopLevelVariableElement` defines the behavior of elements representing a
  * top-level variable.
- *
- * @coverage dart.engine.element
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {
 }
 
 /**
  * The interface `TypeParameterElement` defines the behavior of elements representing a type
  * parameter.
- *
- * @coverage dart.engine.element
  */
 abstract class TypeParameterElement implements Element {
   /**
    * Return the type representing the bound associated with this parameter, or `null` if this
    * parameter does not have an explicit bound.
    *
    * @return the type representing the bound associated with this parameter
    */
   Type2 get bound;
 
   /**
    * Return the type defined by this type parameter.
    *
    * @return the type defined by this type parameter
    */
   TypeParameterType get type;
 }
 
 /**
  * The interface `UndefinedElement` defines the behavior of pseudo-elements that represent
  * names that are undefined. This situation is not allowed by the language, so objects implementing
  * this interface always represent an error. As a result, most of the normal operations on elements
  * do not make sense and will return useless results.
- *
- * @coverage dart.engine.element
  */
 abstract class UndefinedElement implements Element {
 }
 
 /**
  * The interface `UriReferencedElement` defines the behavior of objects included into a
  * library using some URI.
- *
- * @coverage dart.engine.element
  */
 abstract class UriReferencedElement implements Element {
   /**
    * Return the URI that is used to include this element into the enclosing library, or `null`
    * if this is the defining compilation unit of a library.
    *
    * @return the URI that is used to include this element into the enclosing library
    */
   String get uri;
 }
 
 /**
  * The interface `VariableElement` defines the behavior common to elements that represent a
  * variable.
- *
- * @coverage dart.engine.element
  */
 abstract class VariableElement implements Element {
   /**
    * 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.
    *
    * @return a synthetic function representing this variable's initializer
    */
   FunctionElement get initializer;
@@ skipping 30 matching lines @@
    * final.
    *
    * @return `true` if this variable was declared with the 'final' modifier
    */
   bool get isFinal;
 }
 
 /**
  * The interface `AngularControllerElement` defines the Angular component described by
  * <code>NgComponent</code> annotation.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularComponentElement implements AngularHasSelectorElement, AngularHasTemplateElement {
   /**
    * Return an array containing all of the properties declared by this component.
    */
   List<AngularPropertyElement> get properties;
 
   /**
    * Return an array containing all of the scope properties set in the implementation of this
    * component.
    */
   List<AngularScopePropertyElement> get scopeProperties;
 
   /**
    * Returns the CSS file URI.
    */
   String get styleUri;
 
   /**
    * Return the offset of the [getStyleUri] in the [getSource].
    *
    * @return the offset of the style URI
    */
   int get styleUriOffset;
 }
 
 /**
  * The interface `AngularControllerElement` defines the Angular controller described by
  * <code>NgController</code> annotation.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularControllerElement implements AngularHasSelectorElement {
 }
 
 /**
  * The interface `AngularDirectiveElement` defines the Angular controller described by
  * <code>NgDirective</code> annotation.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularDirectiveElement implements AngularHasSelectorElement {
   /**
    * Return an array containing all of the properties declared by this directive.
    */
   List<AngularPropertyElement> get properties;
 
   /**
    * Checks if this directive is implemented by the class with given name.
    */
   bool isClass(String name);
 }
 
 /**
  * The interface `AngularElement` defines the behavior of objects representing information
  * about an Angular specific element.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularElement implements ToolkitObjectElement {
   /**
    * An empty array of angular elements.
    */
   static final List<AngularElement> EMPTY_ARRAY = new List<AngularElement>(0);
 
   /**
    * Returns the [AngularApplication] this element is used in.
    *
    * @return the [AngularApplication] this element is used in
    */
   AngularApplication get application;
 }
 
 /**
  * The interface `AngularFilterElement` defines the Angular filter described by
  * <code>NgFilter</code> annotation.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularFilterElement implements AngularElement {
 }
 
 /**
  * [AngularSelectorElement] based on presence of attribute.
  */
 abstract class AngularHasAttributeSelectorElement implements AngularSelectorElement {
 }
 
 /**
  * [AngularSelectorElement] based on presence of a class.
  */
 abstract class AngularHasClassSelectorElement implements AngularSelectorElement {
 }
 
 /**
  * The interface `AngularElement` defines the behavior of objects representing information
  * about an Angular element which is applied conditionally using some [AngularSelectorElement].
- *
- * @coverage dart.engine.element
  */
 abstract class AngularHasSelectorElement implements AngularElement {
   /**
    * Returns the selector specified for this element.
    *
    * @return the [AngularSelectorElement] specified for this element
    */
   AngularSelectorElement get selector;
 }
 
 /**
  * The interface `AngularHasTemplateElement` defines common behavior for
  * [AngularElement] that have template URI / [Source].
- *
- * @coverage dart.engine.element
  */
 abstract class AngularHasTemplateElement implements AngularElement {
   /**
    * Returns the HTML template [Source], `null` if not resolved.
    */
   Source get templateSource;
 
   /**
    * Returns the HTML template URI.
    */
   String get templateUri;
 
   /**
    * Return the offset of the [getTemplateUri] in the [getSource].
    *
    * @return the offset of the template URI
    */
   int get templateUriOffset;
 }
 
 /**
  * The interface `AngularPropertyElement` defines a single property in
  * [AngularComponentElement].
- *
- * @coverage dart.engine.element
  */
 abstract class AngularPropertyElement implements AngularElement {
   /**
    * An empty array of property elements.
    */
   static final List<AngularPropertyElement> EMPTY_ARRAY = [];
 
   /**
    * Returns the field this property is mapped to.
    *
@@ skipping 12 matching lines @@
   /**
    * Returns the kind of this property.
    *
    * @return the kind of this property
    */
   AngularPropertyKind get propertyKind;
 }
 
 /**
  * The enumeration `AngularPropertyKind` defines the different kinds of property bindings.
- *
- * @coverage dart.engine.element
  */
 class AngularPropertyKind extends Enum<AngularPropertyKind> {
   /**
    * `@` - Map the DOM attribute string. The attribute string will be taken literally or
    * interpolated if it contains binding {{}} syntax and assigned to the expression. (cost: 0
    * watches)
    */
   static final AngularPropertyKind ATTR = new AngularPropertyKind('ATTR', 0);
 
   /**
@@ skipping 39 matching lines @@
 
 class AngularPropertyKind_TWO_WAY extends AngularPropertyKind {
   AngularPropertyKind_TWO_WAY(String name, int ordinal) : super(name, ordinal);
 
   bool callsGetter() => true;
 }
 
 /**
  * The interface `AngularScopeVariableElement` defines the Angular <code>Scope</code>
  * property. They are created for every <code>scope['property'] = value;</code> code snippet.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularScopePropertyElement implements AngularElement {
   /**
    * An empty array of scope property elements.
    */
   static final List<AngularScopePropertyElement> EMPTY_ARRAY = [];
 
   /**
    * Returns the type of this property, not `null`, maybe <code>dynamic</code>.
    *
@@ skipping 20 matching lines @@
 
 /**
  * [AngularSelectorElement] based on tag name.
  */
 abstract class AngularTagSelectorElement implements AngularSelectorElement {
 }
 
 /**
  * The interface `AngularViewElement` defines the Angular view defined using invocation like
  * <code>view('views/create.html')</code>.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularViewElement implements AngularHasTemplateElement {
   /**
    * An empty array of view elements.
    */
   static final List<AngularViewElement> EMPTY_ARRAY = new List<AngularViewElement>(0);
 }
 
 /**
  * Instances of the class `GeneralizingElementVisitor` implement an element visitor that will
@@ skipping 42 matching lines @@
  *      LocalElement
  *         LocalVariableElement
  *         ParameterElement
  *            FieldFormalParameterElement
  * </pre>
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
  * explicitly invoke the more general visit method. Failure to do so will cause the visit methods
  * for superclasses of the element to not be invoked and will cause the children of the visited node
  * to not be visited.
- *
- * @coverage dart.engine.element
  */
 class GeneralizingElementVisitor<R> implements ElementVisitor<R> {
   R visitAngularComponentElement(AngularComponentElement element) => visitAngularHasSelectorElement(element);
 
   R visitAngularControllerElement(AngularControllerElement element) => visitAngularHasSelectorElement(element);
 
   R visitAngularDirectiveElement(AngularDirectiveElement element) => visitAngularHasSelectorElement(element);
 
   R visitAngularElement(AngularElement element) => visitToolkitObjectElement(element);
 
@@ skipping 82 matching lines @@
 
 /**
  * Instances of the class `RecursiveElementVisitor` implement an element visitor that will
  * recursively visit all of the element in an element model. For example, using an instance of this
  * class to visit a [CompilationUnitElement] will also cause all of the types in the
  * compilation unit to be visited.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or must
  * explicitly ask the visited element to visit its children. Failure to do so will cause the
  * children of the visited element to not be visited.
- *
- * @coverage dart.engine.element
  */
 class RecursiveElementVisitor<R> implements ElementVisitor<R> {
   R visitAngularComponentElement(AngularComponentElement element) {
     element.visitChildren(this);
     return null;
   }
 
   R visitAngularControllerElement(AngularControllerElement element) {
     element.visitChildren(this);
     return null;
@@ skipping 138 matching lines @@
     element.visitChildren(this);
     return null;
   }
 }
 
 /**
  * Instances of the class `SimpleElementVisitor` implement an element visitor that will do
  * nothing when visiting an element. It is intended to be a superclass for classes that use the
  * visitor pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a
  * whole structure) and that only need to visit a small number of element types.
- *
- * @coverage dart.engine.element
  */
 class SimpleElementVisitor<R> implements ElementVisitor<R> {
   R visitAngularComponentElement(AngularComponentElement element) => null;
 
   R visitAngularControllerElement(AngularControllerElement element) => null;
 
   R visitAngularDirectiveElement(AngularDirectiveElement element) => null;
 
   R visitAngularFilterElement(AngularFilterElement element) => null;
 
@@ skipping 74 matching lines @@
    * Create the [AuxiliaryElements] with a static and propagated [ExecutableElement].
    *
    * @param staticElement the static element
    * @param propagatedElement the propagated element
    */
   AuxiliaryElements(this.staticElement, this.propagatedElement);
 }
 
 /**
  * Instances of the class `ClassElementImpl` implement a `ClassElement`.
- *
- * @coverage dart.engine.element
  */
 class ClassElementImpl extends ElementImpl implements ClassElement {
   /**
    * An array containing all of the accessors (getters and setters) contained in this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the constructors contained in this class.
    */
@@ skipping 491 matching lines @@
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * Instances of the class `CompilationUnitElementImpl` implement a
  * [CompilationUnitElement].
- *
- * @coverage dart.engine.element
  */
 class CompilationUnitElementImpl extends ElementImpl implements CompilationUnitElement {
   /**
    * An empty array of compilation unit elements.
    */
   static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
 
   /**
    * The source that corresponds to this compilation unit.
    */
@@ skipping 252 matching lines @@
   EvaluationResultImpl get evaluationResult => _result;
 
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `ConstLocalVariableElementImpl` implement a
  * `LocalVariableElement` for a local 'const' variable that has an initializer.
- *
- * @coverage dart.engine.element
  */
 class ConstLocalVariableElementImpl extends LocalVariableElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
@@ skipping 27 matching lines @@
 
   EvaluationResultImpl get evaluationResult => _result;
 
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `ConstructorElementImpl` implement a `ConstructorElement`.
- *
- * @coverage dart.engine.element
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
    * An empty array of constructor elements.
    */
   static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>(0);
 
   /**
    * The constructor to which this constructor is redirecting.
    */
@@ skipping 70 matching lines @@
       builder.append(".");
       builder.append(name);
     }
     super.appendTo(builder);
   }
 }
 
 /**
  * Instances of the class `DefaultFieldFormalParameterElementImpl` implement a
  * `FieldFormalParameterElementImpl` for parameters that have an initializer.
- *
- * @coverage dart.engine.element
  */
 class DefaultFieldFormalParameterElementImpl extends FieldFormalParameterElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   DefaultFieldFormalParameterElementImpl(Identifier name) : super(name);
 
   EvaluationResultImpl get evaluationResult => _result;
 
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `DefaultParameterElementImpl` implement a `ParameterElement`
  * for parameters that have an initializer.
- *
- * @coverage dart.engine.element
  */
 class DefaultParameterElementImpl extends ParameterElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   DefaultParameterElementImpl(Identifier name) : super.con1(name);
 
   EvaluationResultImpl get evaluationResult => _result;
 
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `DynamicElementImpl` represent the synthetic element representing
  * the declaration of the type `dynamic`.
- *
- * @coverage dart.engine.element
  */
 class DynamicElementImpl extends ElementImpl {
   /**
    * Return the unique instance of this class.
    *
    * @return the unique instance of this class
    */
   static DynamicElementImpl get instance => DynamicTypeImpl.instance.element as DynamicElementImpl;
 
   /**
@@ skipping 10 matching lines @@
     setModifier(Modifier.SYNTHETIC, true);
   }
 
   accept(ElementVisitor visitor) => null;
 
   ElementKind get kind => ElementKind.DYNAMIC;
 }
 
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
- *
- * @coverage dart.engine.element
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
   final Element element;
 
   /**
    * An empty array of annotations.
    */
@@ skipping 68 matching lines @@
     }
     return false;
   }
 
   String toString() => "@${element.toString()}";
 }
 
 /**
  * The abstract class `ElementImpl` implements the behavior common to objects that implement
  * an [Element].
- *
- * @coverage dart.engine.element
  */
 abstract class ElementImpl implements Element {
   /**
    * 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.
@@ skipping 84 matching lines @@
   String get displayName => _name;
 
   Element get enclosingElement => _enclosingElement;
 
   LibraryElement get library => getAncestor(LibraryElement);
 
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
   String get name => _name;
 
-  ASTNode get node => getNode2(ASTNode);
+  AstNode get node => getNode2(AstNode);
 
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
 
   CompilationUnit get unit => context.resolveCompilationUnit(source, library);
 
@@ skipping 87 matching lines @@
 
   /**
    * Return an identifier that uniquely identifies this element among the children of this element's
    * parent.
    *
    * @return an identifier that uniquely identifies this element relative to its parent
    */
   String get identifier => name;
 
   /**
-   * Return the resolved [ASTNode] of the given type enclosing [getNameOffset].
+   * Return the resolved [AstNode] of the given type enclosing [getNameOffset].
    */
-  ASTNode getNode2(Type clazz) {
+  AstNode getNode2(Type clazz) {
     CompilationUnit unit = this.unit;
     if (unit == null) {
       return null;
     }
     int offset = nameOffset;
-    ASTNode node = new NodeLocator.con1(offset).searchWithin(unit);
+    AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
     if (node == null) {
       return null;
     }
     return node.getAncestor(clazz);
   }
 
   /**
    * Return `true` if this element has the given modifier associated with it.
    *
    * @param modifier the modifier being tested for
@@ skipping 43 matching lines @@
    * @param modifier the modifier to be set
    * @param value `true` if the modifier is to be associated with this element
    */
   void setModifier(Modifier modifier, bool value) {
     _modifiers = BooleanArray.set(_modifiers, modifier, value);
   }
 }
 
 /**
  * Instances of the class `ElementLocationImpl` implement an [ElementLocation].
- *
- * @coverage dart.engine.element
  */
 class ElementLocationImpl implements ElementLocation {
   /**
    * The path to the element whose location is represented by this object.
    */
   List<String> _components;
 
   /**
    * The character used to separate components in the encoded form.
    */
@@ skipping 226 matching lines @@
    * @return the second element
    */
   Element get secondElt => _second;
 
   int get hashCode => ObjectUtilities.combineHashCodes(_first.hashCode, _second.hashCode);
 }
 
 /**
  * Instances of the class `EmbeddedHtmlScriptElementImpl` implement an
  * [EmbeddedHtmlScriptElement].
- *
- * @coverage dart.engine.element
  */
 class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl implements EmbeddedHtmlScriptElement {
   /**
    * The library defined by the script tag's content.
    */
   LibraryElement _scriptLibrary;
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
@@ skipping 18 matching lines @@
   }
 
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_scriptLibrary, visitor);
   }
 }
 
 /**
  * The abstract class `ExecutableElementImpl` implements the behavior common to
  * `ExecutableElement`s.
- *
- * @coverage dart.engine.element
  */
 abstract class ExecutableElementImpl extends ElementImpl implements ExecutableElement {
   /**
    * An array containing all of the functions defined within this executable element.
    */
   List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the labels defined within this executable element.
    */
@@ skipping 166 matching lines @@
     }
     if (type != null) {
       builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `ExportElementImpl` implement an [ExportElement].
- *
- * @coverage dart.engine.element
  */
 class ExportElementImpl extends ElementImpl implements ExportElement {
   /**
    * The URI that is specified by this directive.
    */
   String uri;
 
   /**
    * The library that is exported from this library by this export directive.
    */
@@ skipping 18 matching lines @@
     builder.append("export ");
     (exportedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
   String get identifier => exportedLibrary.name;
 }
 
 /**
  * Instances of the class `ExternalHtmlScriptElementImpl` implement an
  * [ExternalHtmlScriptElement].
- *
- * @coverage dart.engine.element
  */
 class ExternalHtmlScriptElementImpl extends HtmlScriptElementImpl implements ExternalHtmlScriptElement {
   /**
    * The source specified in the `source` attribute or `null` if unspecified.
    */
   Source scriptSource;
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node);
 
   accept(ElementVisitor visitor) => visitor.visitExternalHtmlScriptElement(this);
 
   ElementKind get kind => ElementKind.EXTERNAL_HTML_SCRIPT;
 }
 
 /**
  * Instances of the class `FieldElementImpl` implement a `FieldElement`.
- *
- * @coverage dart.engine.element
  */
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
   /**
    * An empty array of field elements.
    */
   static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);
 
   /**
    * Initialize a newly created field element to have the given name.
    *
@@ skipping 23 matching lines @@
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 }
 
 /**
  * Instances of the class `FieldFormalParameterElementImpl` extend
  * [ParameterElementImpl] to provide the additional information of the [FieldElement]
  * associated with the parameter.
- *
- * @coverage dart.engine.element
  */
 class FieldFormalParameterElementImpl extends ParameterElementImpl implements FieldFormalParameterElement {
   /**
    * The field associated with this field formal parameter.
    */
   FieldElement field;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   FieldFormalParameterElementImpl(Identifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
 
   bool get isInitializingFormal => true;
 }
 
 /**
  * Instances of the class `FunctionElementImpl` implement a `FunctionElement`.
- *
- * @coverage dart.engine.element
  */
 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.
@@ skipping 56 matching lines @@
     }
     super.appendTo(builder);
   }
 
   String get identifier => "${name}@${nameOffset}";
 }
 
 /**
  * Instances of the class `FunctionTypeAliasElementImpl` implement a
  * `FunctionTypeAliasElement`.
- *
- * @coverage dart.engine.element
  */
 class FunctionTypeAliasElementImpl extends ElementImpl implements FunctionTypeAliasElement {
   /**
    * An array containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The return type defined by this type alias.
    */
@@ skipping 127 matching lines @@
     if (type != null) {
       builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `HideElementCombinatorImpl` implement a
  * [HideElementCombinator].
- *
- * @coverage dart.engine.element
  */
 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;
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("show ");
     int count = hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(hiddenNames[i]);
     }
     return builder.toString();
   }
 }
 
 /**
  * Instances of the class `HtmlElementImpl` implement an [HtmlElement].
- *
- * @coverage dart.engine.element
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty array of HTML file elements.
    */
   static List<HtmlElement> EMPTY_ARRAY = new List<HtmlElement>(0);
 
   /**
    * The analysis context in which this library is defined.
    */
@@ skipping 65 matching lines @@
     if (source == null) {
       builder.append("{HTML file}");
     } else {
       builder.append(source.fullName);
     }
   }
 }
 
 /**
  * Instances of the class `HtmlScriptElementImpl` implement an [HtmlScriptElement].
- *
- * @coverage dart.engine.element
  */
 abstract class HtmlScriptElementImpl extends ElementImpl implements HtmlScriptElement {
   /**
    * An empty array of HTML script elements.
    */
   static List<HtmlScriptElement> EMPTY_ARRAY = new List<HtmlScriptElement>(0);
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   HtmlScriptElementImpl(XmlTagNode node) : super.con2(node.tag, node.tagToken.offset);
 }
 
 /**
  * Instances of the class `ImportElementImpl` implement an [ImportElement].
- *
- * @coverage dart.engine.element
  */
 class ImportElementImpl extends ElementImpl implements ImportElement {
   /**
    * The offset of the character immediately following the last character of this node's URI, may be
    * `-1` if synthetic.
    */
   int uriEnd = -1;
 
   /**
    * The offset of the prefix of this import in the file that contains the this import directive, or
@@ skipping 42 matching lines @@
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     (importedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
   String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${nameOffset}";
 }
 
 /**
  * Instances of the class `LabelElementImpl` implement a `LabelElement`.
- *
- * @coverage dart.engine.element
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch` statement.
    */
   bool _onSwitchStatement = false;
 
   /**
    * A flag indicating whether this label is associated with a `switch` member (`case`
    * or `default`).
@@ skipping 35 matching lines @@
   /**
    * Return `true` if this label is associated with a `switch` statement.
    *
    * @return `true` if this label is associated with a `switch` statement
    */
   bool get isOnSwitchStatement => _onSwitchStatement;
 }
 
 /**
  * Instances of the class `LibraryElementImpl` implement a `LibraryElement`.
- *
- * @coverage dart.engine.element
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
    * An empty array of library elements.
    */
   static List<LibraryElement> EMPTY_ARRAY = new List<LibraryElement>(0);
 
   /**
    * Determine if the given library is up to date with respect to the given time stamp.
    *
@@ skipping 325 matching lines @@
           visited.add(exportedLibrary);
         }
       }
     }
     return false;
   }
 }
 
 /**
  * Instances of the class `LocalVariableElementImpl` implement a `LocalVariableElement`.
- *
- * @coverage dart.engine.element
  */
 class LocalVariableElementImpl extends VariableElementImpl implements LocalVariableElement {
   /**
    * Is `true` if this variable is potentially mutated somewhere in its scope.
    */
   bool _isPotentiallyMutatedInScope2 = false;
 
   /**
    * Is `true` if this variable is potentially mutated somewhere in closure.
    */
@@ skipping 89 matching lines @@
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 
   String get identifier => "${super.identifier}@${nameOffset}";
 }
 
 /**
  * Instances of the class `MethodElementImpl` implement a `MethodElement`.
- *
- * @coverage dart.engine.element
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty array of method elements.
    */
   static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
 
   /**
    * Initialize a newly created method element to have the given name.
    *
@@ skipping 63 matching lines @@
     builder.append(enclosingElement.displayName);
     builder.append(".");
     builder.append(displayName);
     super.appendTo(builder);
   }
 }
 
 /**
  * The enumeration `Modifier` defines constants for all of the modifiers defined by the Dart
  * language and for a few additional flags that are useful.
- *
- * @coverage dart.engine.element
  */
 class Modifier extends Enum<Modifier> {
   /**
    * Indicates that the modifier 'abstract' was applied to the element.
    */
   static final Modifier ABSTRACT = new Modifier('ABSTRACT', 0);
 
   /**
    * Indicates that the modifier 'const' was applied to the element.
    */
@@ skipping 56 matching lines @@
       STATIC,
       SYNTHETIC,
       TYPEDEF];
 
   Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * Instances of the class `MultiplyDefinedElementImpl` represent a collection of elements that
  * have the same name within the same scope.
- *
- * @coverage dart.engine.element
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
   /**
    * Return an element that represents the given conflicting elements.
    *
    * @param context the analysis context in which the multiply defined elements are defined
    * @param firstElement the first element that conflicts
    * @param secondElement the second element that conflicts
    */
   static Element fromElements(AnalysisContext context, Element firstElement, Element secondElement) {
@@ skipping 80 matching lines @@
   LibraryElement get library => null;
 
   ElementLocation get location => null;
 
   List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
 
   String get name => _name;
 
   int get nameOffset => -1;
 
-  ASTNode get node => null;
+  AstNode get node => null;
 
   Source get source => null;
 
   Type2 get type => DynamicTypeImpl.instance;
 
   CompilationUnit get unit => null;
 
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in conflictingElements) {
       if (element.isAccessibleIn(library)) {
@@ skipping 34 matching lines @@
   }
 
   void visitChildren(ElementVisitor visitor) {
   }
 }
 
 /**
  * The interface [MultiplyInheritedMethodElementImpl] defines all of the behavior of an
  * [MethodElementImpl], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
- *
- * @coverage dart.engine.element
  */
 class MultiplyInheritedMethodElementImpl extends MethodElementImpl implements MultiplyInheritedExecutableElement {
   /**
    * An array the array of executable elements that were used to compose this element.
    */
   List<ExecutableElement> _elements = MethodElementImpl.EMPTY_ARRAY;
 
   MultiplyInheritedMethodElementImpl(Identifier name) : super.con1(name) {
     synthetic = true;
   }
 
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * The interface [MultiplyInheritedPropertyAccessorElementImpl] defines all of the behavior of
  * an [PropertyAccessorElementImpl], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
- *
- * @coverage dart.engine.element
  */
 class MultiplyInheritedPropertyAccessorElementImpl extends PropertyAccessorElementImpl implements MultiplyInheritedExecutableElement {
   /**
    * An array the array of executable elements that were used to compose this element.
    */
   List<ExecutableElement> _elements = PropertyAccessorElementImpl.EMPTY_ARRAY;
 
   MultiplyInheritedPropertyAccessorElementImpl(Identifier name) : super.con1(name) {
     synthetic = true;
   }
 
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * Instances of the class `ParameterElementImpl` implement a `ParameterElement`.
- *
- * @coverage dart.engine.element
  */
 class ParameterElementImpl extends VariableElementImpl implements ParameterElement {
   /**
    * Is `true` if this variable is potentially mutated somewhere in its scope.
    */
   bool _isPotentiallyMutatedInScope3 = false;
 
   /**
    * Is `true` if this variable is potentially mutated somewhere in closure.
    */
@@ skipping 162 matching lines @@
    */
   void appendToWithoutDelimiters(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 }
 
 /**
  * Instances of the class `PrefixElementImpl` implement a `PrefixElement`.
- *
- * @coverage dart.engine.element
  */
 class PrefixElementImpl extends ElementImpl implements PrefixElement {
   /**
    * An array containing all of the libraries that are imported using this prefix.
    */
   List<LibraryElement> _importedLibraries = LibraryElementImpl.EMPTY_ARRAY;
 
   /**
    * An empty array of prefix elements.
    */
@@ skipping 30 matching lines @@
     builder.append("as ");
     super.appendTo(builder);
   }
 
   String get identifier => "_${super.identifier}";
 }
 
 /**
  * Instances of the class `PropertyAccessorElementImpl` implement a
  * `PropertyAccessorElement`.
- *
- * @coverage dart.engine.element
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
   /**
    * The variable associated with this accessor.
    */
   PropertyInducingElement variable;
 
   /**
    * An empty array of property accessor elements.
    */
@@ skipping 42 matching lines @@
     return ElementKind.SETTER;
   }
 
   String get name {
     if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
 
-  ASTNode get node {
+  AstNode get node {
     if (isSynthetic) {
       return null;
     }
     if (enclosingElement is ClassElement) {
       return getNode2(MethodDeclaration);
     }
     if (enclosingElement is CompilationUnitElement) {
       return getNode2(FunctionDeclaration);
     }
     return null;
@@ skipping 48 matching lines @@
   void appendTo(JavaStringBuilder builder) {
     builder.append(isGetter ? "get " : "set ");
     builder.append(variable.displayName);
     super.appendTo(builder);
   }
 }
 
 /**
  * Instances of the class `PropertyInducingElementImpl` implement a
  * `PropertyInducingElement`.
- *
- * @coverage dart.engine.element
  */
 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.
@@ skipping 18 matching lines @@
    * @param name the name of this element
    */
   PropertyInducingElementImpl.con2(String name) : super.con2(name, -1) {
     synthetic = true;
   }
 }
 
 /**
  * Instances of the class `ShowElementCombinatorImpl` implement a
  * [ShowElementCombinator].
- *
- * @coverage dart.engine.element
  */
 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.
@@ skipping 14 matching lines @@
         builder.append(", ");
       }
       builder.append(shownNames[i]);
     }
     return builder.toString();
   }
 }
 
 /**
  * Instances of the class `ToolkitObjectElementImpl` implement a `ToolkitObjectElement`.
- *
- * @coverage dart.engine.element
  */
 abstract class ToolkitObjectElementImpl extends ElementImpl implements ToolkitObjectElement {
   /**
    * Initialize a newly created toolkit object element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   ToolkitObjectElementImpl(String name, int nameOffset) : super.con2(name, nameOffset);
 }
 
 /**
  * Instances of the class `TopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement`.
- *
- * @coverage dart.engine.element
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements TopLevelVariableElement {
   /**
    * An empty array of top-level variable elements.
    */
   static List<TopLevelVariableElement> EMPTY_ARRAY = new List<TopLevelVariableElement>(0);
 
   /**
    * Initialize a newly created top-level variable element to have the given name.
    *
@@ skipping 10 matching lines @@
 
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
 
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
 
   bool get isStatic => true;
 }
 
 /**
  * Instances of the class `TypeParameterElementImpl` implement a [TypeParameterElement].
- *
- * @coverage dart.engine.element
  */
 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.
@@ skipping 20 matching lines @@
     builder.append(displayName);
     if (bound != null) {
       builder.append(" extends ");
       builder.append(bound);
     }
   }
 }
 
 /**
  * Instances of the class `VariableElementImpl` implement a `VariableElement`.
- *
- * @coverage dart.engine.element
  */
 abstract class VariableElementImpl extends ElementImpl implements VariableElement {
   /**
    * The declared type of this variable.
    */
   Type2 type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if this variable
    * does not have an initializer.
@@ skipping 125 matching lines @@
   }
 
   /**
    * Checks if this application depends on the library with the given [Source].
    */
   bool dependsOn(Source librarySource) => _librarySources.contains(librarySource);
 }
 
 /**
  * Implementation of `AngularComponentElement`.
- *
- * @coverage dart.engine.element
  */
 class AngularComponentElementImpl extends AngularHasSelectorElementImpl implements AngularComponentElement {
   /**
    * The offset of the defining <code>NgComponent</code> annotation.
    */
   int _annotationOffset = 0;
 
   /**
    * The array containing all of the properties declared by this component.
    */
@@ skipping 76 matching lines @@
     safelyVisitChildren(_properties, visitor);
     safelyVisitChildren(_scopeProperties, visitor);
     super.visitChildren(visitor);
   }
 
   String get identifier => "AngularComponent@${_annotationOffset}";
 }
 
 /**
  * Implementation of `AngularControllerElement`.
- *
- * @coverage dart.engine.element
  */
 class AngularControllerElementImpl extends AngularHasSelectorElementImpl implements AngularControllerElement {
   /**
    * Initialize a newly created Angular controller to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularControllerElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   accept(ElementVisitor visitor) => visitor.visitAngularControllerElement(this);
 
   ElementKind get kind => ElementKind.ANGULAR_CONTROLLER;
 }
 
 /**
  * Implementation of `AngularDirectiveElement`.
- *
- * @coverage dart.engine.element
  */
 class AngularDirectiveElementImpl extends AngularHasSelectorElementImpl implements AngularDirectiveElement {
   /**
    * The offset of the annotation that defines this directive.
    */
   int _offset = 0;
 
   /**
    * The array containing all of the properties declared by this directive.
    */
@@ skipping 36 matching lines @@
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChildren(_properties, visitor);
     super.visitChildren(visitor);
   }
 
   String get identifier => "NgDirective@${_offset}";
 }
 
 /**
  * Implementation of `AngularElement`.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularElementImpl extends ToolkitObjectElementImpl implements AngularElement {
   /**
    * The [AngularApplication] this element is used in.
    */
   AngularApplication _application;
 
   /**
    * Initialize a newly created Angular element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   AngularApplication get application => _application;
 
   /**
    * Set the [AngularApplication] this element is used in.
    */
   void set application(AngularApplication application) {
     this._application = application;
   }
 }
 
 /**
  * Implementation of `AngularFilterElement`.
- *
- * @coverage dart.engine.element
  */
 class AngularFilterElementImpl extends AngularElementImpl implements AngularFilterElement {
   /**
    * Initialize a newly created Angular filter to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularFilterElementImpl(String name, int nameOffset) : super(name, nameOffset);
@@ skipping 26 matching lines @@
   }
 
   void appendTo(JavaStringBuilder builder) {
     builder.append(".");
     builder.append(name);
   }
 }
 
 /**
  * Implementation of `AngularSelectorElement`.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularHasSelectorElementImpl extends AngularElementImpl implements AngularHasSelectorElement {
   /**
    * The selector of this element.
    */
   AngularSelectorElement _selector;
 
   /**
    * Initialize a newly created Angular element to have the given name.
    *
@@ skipping 16 matching lines @@
   }
 
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_selector, visitor);
     super.visitChildren(visitor);
   }
 }
 
 /**
  * Implementation of `AngularPropertyElement`.
- *
- * @coverage dart.engine.element
  */
 class AngularPropertyElementImpl extends AngularElementImpl implements AngularPropertyElement {
   /**
    * The [FieldElement] to which this property is bound.
    */
   FieldElement field;
 
   /**
    * The offset of the field name in the property map.
    */
@@ skipping 10 matching lines @@
    */
   AngularPropertyElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   accept(ElementVisitor visitor) => visitor.visitAngularPropertyElement(this);
 
   ElementKind get kind => ElementKind.ANGULAR_PROPERTY;
 }
 
 /**
  * Implementation of `AngularScopePropertyElement`.
- *
- * @coverage dart.engine.element
  */
 class AngularScopePropertyElementImpl extends AngularElementImpl implements AngularScopePropertyElement {
   /**
    * The type of the property
    */
   final Type2 type;
 
   /**
    * Initialize a newly created Angular scope property to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularScopePropertyElementImpl(String name, int nameOffset, this.type) : super(name, nameOffset);
 
   accept(ElementVisitor visitor) => visitor.visitAngularScopePropertyElement(this);
 
   ElementKind get kind => ElementKind.ANGULAR_SCOPE_PROPERTY;
 }
 
 /**
  * Implementation of `AngularFilterElement`.
- *
- * @coverage dart.engine.element
  */
 abstract class AngularSelectorElementImpl extends AngularElementImpl implements AngularSelectorElement {
   /**
    * Initialize a newly created Angular selector to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularSelectorElementImpl(String name, int nameOffset) : super(name, nameOffset);
@@ skipping 12 matching lines @@
   bool apply(XmlTagNode node) {
     String tagName = name;
     return node.tag == tagName;
   }
 
   AngularApplication get application => (enclosingElement as AngularElementImpl).application;
 }
 
 /**
  * Implementation of `AngularViewElement`.
- *
- * @coverage dart.engine.element
  */
 class AngularViewElementImpl extends AngularElementImpl implements AngularViewElement {
   /**
    * The HTML template URI.
    */
   final String templateUri;
 
   /**
    * The offset of the [templateUri] in the [getSource].
    */
@@ skipping 324 matching lines @@
   LibraryElement get library => _baseElement.library;
 
   ElementLocation get location => _baseElement.location;
 
   List<ElementAnnotation> get metadata => _baseElement.metadata;
 
   String get name => _baseElement.name;
 
   int get nameOffset => _baseElement.nameOffset;
 
-  ASTNode get node => _baseElement.node;
+  AstNode get node => _baseElement.node;
 
   Source get source => _baseElement.source;
 
   CompilationUnit get unit => _baseElement.unit;
 
   bool isAccessibleIn(LibraryElement library) => _baseElement.isAccessibleIn(library);
 
   bool get isDeprecated => _baseElement.isDeprecated;
 
   bool get isOverride => _baseElement.isOverride;
@@ skipping 398 matching lines @@
   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 unique instance of the class `BottomTypeImpl` implements the type `bottom`.
- *
- * @coverage dart.engine.type
  */
 class BottomTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static BottomTypeImpl _INSTANCE = new BottomTypeImpl();
 
   /**
    * Return the unique instance of this class.
    *
@@ skipping 18 matching lines @@
 
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, this);
 
   bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 
   bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
  * The unique instance of the class `DynamicTypeImpl` implements the type `dynamic`.
- *
- * @coverage dart.engine.type
  */
 class DynamicTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static DynamicTypeImpl _INSTANCE = new DynamicTypeImpl();
 
   /**
    * Return the unique instance of this class.
    *
@@ skipping 36 matching lines @@
     // else
     return withDynamic;
   }
 
   bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
  * Instances of the class `FunctionTypeImpl` defines the behavior common to objects
  * representing the type of a function, method, constructor, getter, or setter.
- *
- * @coverage dart.engine.type
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
    * Return `true` if all of the name/type pairs in the first map are equal to the
    * corresponding name/type pairs in the second map. The maps are expected to iterate over their
    * entries in the same order in which those entries were added to the map.
    *
    * @param firstTypes the first map of name/type pairs being compared
    * @param secondTypes the second map of name/type pairs being compared
    * @param visitedElementPairs a set of visited element pairs
@@ skipping 535 matching lines @@
     } else {
       return (element as FunctionTypeAliasElement).returnType;
     }
   }
 }
 
 /**
  * Instances of the class `InterfaceTypeImpl` defines the behavior common to objects
  * representing the type introduced by either a class or an interface, or a reference to such a
  * type.
- *
- * @coverage dart.engine.type
  */
 class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   /**
    * An empty array of types.
    */
   static List<InterfaceType> EMPTY_ARRAY = new List<InterfaceType>(0);
 
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object.
    *
@@ skipping 706 matching lines @@
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * The abstract class `TypeImpl` implements the behavior common to objects representing the
  * declared type of elements in the element model.
- *
- * @coverage dart.engine.type
  */
 abstract class TypeImpl implements Type2 {
   static bool equalArrays(List<Type2> typeArgs1, List<Type2> typeArgs2, Set<ElementPair> visitedElementPairs) {
     if (typeArgs1.length != typeArgs2.length) {
       return false;
     }
     for (int i = 0; i < typeArgs1.length; i++) {
       if (!(typeArgs1[i] as TypeImpl).internalEquals(typeArgs2[i], visitedElementPairs)) {
         return false;
       }
@@ skipping 188 matching lines @@
     if (_secondType != null) {
       secondHashCode = _secondType.element == null ? 0 : _secondType.element.hashCode;
     }
     return firstHashCode + secondHashCode;
   }
 }
 
 /**
  * Instances of the class `TypeParameterTypeImpl` defines the behavior of objects representing
  * the type introduced by a type parameter.
- *
- * @coverage dart.engine.type
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
    * An empty array of type parameter types.
    */
   static List<TypeParameterType> EMPTY_ARRAY = new List<TypeParameterType>(0);
 
   /**
    * Return an array containing the type parameter types defined by the given array of type
    * parameter elements.
@@ skipping 94 matching lines @@
       // Then check upper bound.
       return boundTypeParameter.isMoreSpecificThan4(s, visitedTypes, withDynamic, visitedTypePairs);
     }
     // Check interface type.
     return (bound as TypeImpl).isMoreSpecificThan3(s, withDynamic, visitedTypePairs);
   }
 }
 
 /**
  * The unique instance of the class `VoidTypeImpl` implements the type `void`.
- *
- * @coverage dart.engine.type
  */
 class VoidTypeImpl extends TypeImpl implements VoidType {
   /**
    * The unique instance of this class.
    */
   static VoidTypeImpl _INSTANCE = new VoidTypeImpl();
 
   /**
    * Return the unique instance of this class.
    *
@@ skipping 26 matching lines @@
  * of a function, method, constructor, getter, or setter. Function types come in three variations:
  * <ol>
  * * The types of functions that only have required parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T</i>.
  * * The types of functions with optional positional parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [T<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>]) &rarr;
  * T</i>.
  * * The types of functions with named parameters. These have the general form <i>(T<sub>1</sub>,
  * &hellip;, T<sub>n</sub>, {T<sub>x1</sub> x1, &hellip;, T<sub>xk</sub> xk}) &rarr; T</i>.
  * </ol>
- *
- * @coverage dart.engine.type
  */
 abstract class FunctionType implements ParameterizedType {
   /**
    * Return a map from the names of named parameters to the types of the named parameters of this
    * type of function. The entries in the map will be iterated in the same order as the order in
    * which the named parameters were defined. If there were no named parameters declared then the
    * map will be empty.
    *
    * @return a map from the name to the types of the named parameters of this type of function
    */
@@ skipping 31 matching lines @@
    * @return the type of object returned by this type of function
    */
   Type2 get returnType;
 
   /**
    * Return `true` if this type is a subtype of the given type.
    *
    * A function type <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T</i> is a subtype of the
    * function type <i>(S<sub>1</sub>, &hellip;, S<sub>n</sub>) &rarr; S</i>, if all of the following
    * conditions are met:
-   *
    * * Either
-   *
    * * <i>S</i> is void, or
    * * <i>T &hArr; S</i>.
    *
-   *
    * * For all <i>i</i>, 1 <= <i>i</i> <= <i>n</i>, <i>T<sub>i</sub> &hArr; S<sub>i</sub></i>.
-   *
    * A function type <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [T<sub>n+1</sub>, &hellip;,
    * T<sub>n+k</sub>]) &rarr; T</i> is a subtype of the function type <i>(S<sub>1</sub>, &hellip;,
    * S<sub>n</sub>, [S<sub>n+1</sub>, &hellip;, S<sub>n+m</sub>]) &rarr; S</i>, if all of the
    * following conditions are met:
-   *
    * * Either
-   *
    * * <i>S</i> is void, or
    * * <i>T &hArr; S</i>.
    *
-   *
    * * <i>k</i> >= <i>m</i> and for all <i>i</i>, 1 <= <i>i</i> <= <i>n+m</i>, <i>T<sub>i</sub>
    * &hArr; S<sub>i</sub></i>.
-   *
    * A function type <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {T<sub>x1</sub> x1, &hellip;,
    * T<sub>xk</sub> xk}) &rarr; T</i> is a subtype of the function type <i>(S<sub>1</sub>, &hellip;,
    * S<sub>n</sub>, {S<sub>y1</sub> y1, &hellip;, S<sub>ym</sub> ym}) &rarr; S</i>, if all of the
    * following conditions are met:
-   *
    * * Either
-   *
    * * <i>S</i> is void,
    * * or <i>T &hArr; S</i>.
    *
-   *
    * * For all <i>i</i>, 1 <= <i>i</i> <= <i>n</i>, <i>T<sub>i</sub> &hArr; S<sub>i</sub></i>.
    * * <i>k</i> >= <i>m</i> and <i>y<sub>i</sub></i> in <i>{x<sub>1</sub>, &hellip;,
    * x<sub>k</sub>}</i>, 1 <= <i>i</i> <= <i>m</i>.
    * * For all <i>y<sub>i</sub></i> in <i>{y<sub>1</sub>, &hellip;, y<sub>m</sub>}</i>,
    * <i>y<sub>i</sub> = x<sub>j</sub> => Tj &hArr; Si</i>.
-   *
    * In addition, the following subtype rules apply:
    *
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, []) &rarr; T <: (T<sub>1</sub>, &hellip;,
    * T<sub>n</sub>) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T <: (T<sub>1</sub>, &hellip;,
    * T<sub>n</sub>, {}) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {}) &rarr; T <: (T<sub>1</sub>, &hellip;,
    * T<sub>n</sub>) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T <: (T<sub>1</sub>, &hellip;,
    * T<sub>n</sub>, []) &rarr; T.</i>
@@ skipping 16 matching lines @@
    * @return the result of performing the substitution
    */
   FunctionType substitute3(List<Type2> argumentTypes);
 
   FunctionType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }
 
 /**
  * The interface `InterfaceType` defines the behavior common to objects representing the type
  * introduced by either a class or an interface, or a reference to such a type.
- *
- * @coverage dart.engine.type
  */
 abstract class InterfaceType implements ParameterizedType {
   /**
    * Return an array containing all of the accessors (getters and setters) declared in this type.
    *
    * @return the accessors declared in this type
    */
   List<PropertyAccessorElement> get accessors;
 
   ClassElement get element;
@@ skipping 76 matching lines @@
    * parameters replaced.
    *
    * @return the superclass of this type
    */
   InterfaceType get superclass;
 
   /**
    * Return `true` if this type is a direct supertype of the given type. The implicit
    * interface of class <i>I</i> is a direct supertype of the implicit interface of class <i>J</i>
    * iff:
-   *
    * * <i>I</i> is Object, and <i>J</i> has no extends clause.
    * * <i>I</i> is listed in the extends clause of <i>J</i>.
    * * <i>I</i> is listed in the implements clause of <i>J</i>.
    * * <i>I</i> is listed in the with clause of <i>J</i>.
    * * <i>J</i> is a mixin application of the mixin of <i>I</i>.
    *
-   *
    * @param type the type being compared with this type
    * @return `true` if this type is a direct supertype of the given type
    */
   bool isDirectSupertypeOf(InterfaceType type);
 
   /**
    * Return `true` if this type is more specific than the given type. An interface type
    * <i>T</i> is more specific than an interface type <i>S</i>, written <i>T &laquo; S</i>, if one
    * of the following conditions is met:
-   *
    * * Reflexivity: <i>T</i> is <i>S</i>.
    * * <i>T</i> is bottom.
    * * <i>S</i> is dynamic.
    * * Direct supertype: <i>S</i> is a direct supertype of <i>T</i>.
    * * <i>T</i> is a type parameter and <i>S</i> is the upper bound of <i>T</i>.
    * * Covariance: <i>T</i> is of the form <i>I&lt;T<sub>1</sub>, &hellip;, T<sub>n</sub>&gt;</i>
    * and S</i> is of the form <i>I&lt;S<sub>1</sub>, &hellip;, S<sub>n</sub>&gt;</i> and
    * <i>T<sub>i</sub> &laquo; S<sub>i</sub></i>, <i>1 <= i <= n</i>.
    * * Transitivity: <i>T &laquo; U</i> and <i>U &laquo; S</i>.
    *
-   *
    * @param type the type being compared with this type
    * @return `true` if this type is more specific than the given type
    */
   bool isMoreSpecificThan(Type2 type);
 
   /**
    * Return `true` if this type is a subtype of the given type. An interface type <i>T</i> is
    * a subtype of an interface type <i>S</i>, written <i>T</i> <: <i>S</i>, iff
    * <i>[bottom/dynamic]T</i> &laquo; <i>S</i> (<i>T</i> is more specific than <i>S</i>). If an
    * interface type <i>I</i> includes a method named <i>call()</i>, and the type of <i>call()</i> is
@@ skipping 18 matching lines @@
    *         library
    */
   ConstructorElement lookUpConstructor(String constructorName, LibraryElement library);
 
   /**
    * Return the element representing the getter that results from looking up the given getter in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library);
 
   /**
    * Return the element representing the getter that results from looking up the given getter in the
    * superclass of this class with respect to the given library, or `null` if the look up
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.15.1: <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param getterName the name of the getter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given getter in this class with respect to the given
    *         library
    */
   PropertyAccessorElement lookUpGetterInSuperclass(String getterName, LibraryElement library);
 
   /**
    * Return the element representing the method that results from looking up the given method in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
    * <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect to library
    * <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param methodName the name of the method being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given method in this class with respect to the given
    *         library
    */
   MethodElement lookUpMethod(String methodName, LibraryElement library);
 
   /**
    * Return the element representing the method that results from looking up the given method in the
    * superclass of this class with respect to the given library, or `null` if the look up
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.15.1: <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect
    * to library <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param methodName the name of the method being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given method in this class with respect to the given
    *         library
    */
   MethodElement lookUpMethodInSuperclass(String methodName, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the given setter in
    * this class with respect to the given library, or `null` if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.16:
    * <blockquote> The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param setterName the name of the setter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given setter in this class with respect to the given
    *         library
    */
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library);
 
   /**
    * Return the element representing the setter that results from looking up the given setter in the
    * superclass of this class with respect to the given library, or `null` if the look up
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.16: <blockquote> The result of looking up getter (respectively setter) <i>m</i> in class
    * <i>C</i> with respect to library <i>L</i> is:
-   *
    * * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.
-   *
    * </blockquote>
    *
    * @param setterName the name of the setter being looked up
    * @param library the library with respect to which the lookup is being performed
    * @return the result of looking up the given setter in this class with respect to the given
    *         library
    */
   PropertyAccessorElement lookUpSetterInSuperclass(String setterName, LibraryElement library);
 
   /**
    * Return the type resulting from substituting the given arguments for this type's parameters.
    * This is fully equivalent to `substitute(argumentTypes, getTypeArguments())`.
    *
    * @param argumentTypes the actual type arguments being substituted for the type parameters
    * @return the result of performing the substitution
    */
   InterfaceType substitute4(List<Type2> argumentTypes);
 
   InterfaceType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }
 
 /**
  * The interface `ParameterizedType` defines the behavior common to objects representing a
  * type with type parameters, such as a class or function type alias.
- *
- * @coverage dart.engine.type
  */
 abstract class ParameterizedType implements Type2 {
   /**
    * Return an array 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.
    *
    * @return the actual types of the type arguments
    */
   List<Type2> get typeArguments;
 
   /**
    * Return an array containing all of the type parameters declared for this type.
    *
    * @return the type parameters declared for this type
    */
   List<TypeParameterElement> get typeParameters;
 }
 
 /**
  * The interface `Type` defines the behavior of objects representing the declared type of
  * elements in the element model.
- *
- * @coverage dart.engine.type
  */
 abstract class Type2 {
   /**
    * Return the name of this type as it should appear when presented to users in contexts such as
    * error messages.
    *
    * @return the name of this type
    */
   String get displayName;
 
@@ skipping 107 matching lines @@
    * @param argumentTypes the actual type arguments being substituted for the parameters
    * @param parameterTypes the parameters to be replaced
    * @return the result of performing the substitution
    */
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }
 
 /**
  * The interface `TypeParameterType` defines the behavior of objects representing the type
  * introduced by a type parameter.
- *
- * @coverage dart.engine.type
  */
 abstract class TypeParameterType implements Type2 {
   TypeParameterElement get element;
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
- *
- * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }