New analyzer snapshot.

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';
@@ skipping 697 matching lines @@
  */
 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");
 
-  static final ElementKind ANGULAR_MODULE = new ElementKind('ANGULAR_MODULE', 4, "Angular module");
+  static final ElementKind ANGULAR_PROPERTY = new ElementKind('ANGULAR_PROPERTY', 4, "Angular property");
 
-  static final ElementKind ANGULAR_PROPERTY = new ElementKind('ANGULAR_PROPERTY', 5, "Angular property");
+  static final ElementKind ANGULAR_SELECTOR = new ElementKind('ANGULAR_SELECTOR', 5, "Angular selector");
 
-  static final ElementKind ANGULAR_SELECTOR = new ElementKind('ANGULAR_SELECTOR', 6, "Angular selector");
+  static final ElementKind CLASS = new ElementKind('CLASS', 6, "class");
 
-  static final ElementKind CLASS = new ElementKind('CLASS', 7, "class");
+  static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 7, "compilation unit");
 
-  static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 8, "compilation unit");
+  static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 8, "constructor");
 
-  static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 9, "constructor");
+  static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 9, "<dynamic>");
 
-  static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 10, "<dynamic>");
+  static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 10, "embedded html script");
 
-  static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 11, "embedded html script");
+  static final ElementKind ERROR = new ElementKind('ERROR', 11, "<error>");
 
-  static final ElementKind ERROR = new ElementKind('ERROR', 12, "<error>");
+  static final ElementKind EXPORT = new ElementKind('EXPORT', 12, "export directive");
 
-  static final ElementKind EXPORT = new ElementKind('EXPORT', 13, "export directive");
+  static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 13, "external html script");
 
-  static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 14, "external html script");
+  static final ElementKind FIELD = new ElementKind('FIELD', 14, "field");
 
-  static final ElementKind FIELD = new ElementKind('FIELD', 15, "field");
+  static final ElementKind FUNCTION = new ElementKind('FUNCTION', 15, "function");
 
-  static final ElementKind FUNCTION = new ElementKind('FUNCTION', 16, "function");
+  static final ElementKind GETTER = new ElementKind('GETTER', 16, "getter");
 
-  static final ElementKind GETTER = new ElementKind('GETTER', 17, "getter");
+  static final ElementKind HTML = new ElementKind('HTML', 17, "html");
 
-  static final ElementKind HTML = new ElementKind('HTML', 18, "html");
+  static final ElementKind IMPORT = new ElementKind('IMPORT', 18, "import directive");
 
-  static final ElementKind IMPORT = new ElementKind('IMPORT', 19, "import directive");
+  static final ElementKind LABEL = new ElementKind('LABEL', 19, "label");
 
-  static final ElementKind LABEL = new ElementKind('LABEL', 20, "label");
+  static final ElementKind LIBRARY = new ElementKind('LIBRARY', 20, "library");
 
-  static final ElementKind LIBRARY = new ElementKind('LIBRARY', 21, "library");
+  static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 21, "local variable");
 
-  static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 22, "local variable");
+  static final ElementKind METHOD = new ElementKind('METHOD', 22, "method");
 
-  static final ElementKind METHOD = new ElementKind('METHOD', 23, "method");
+  static final ElementKind NAME = new ElementKind('NAME', 23, "<name>");
 
-  static final ElementKind NAME = new ElementKind('NAME', 24, "<name>");
+  static final ElementKind PARAMETER = new ElementKind('PARAMETER', 24, "parameter");
 
-  static final ElementKind PARAMETER = new ElementKind('PARAMETER', 25, "parameter");
+  static final ElementKind PREFIX = new ElementKind('PREFIX', 25, "import prefix");
 
-  static final ElementKind PREFIX = new ElementKind('PREFIX', 26, "import prefix");
+  static final ElementKind SETTER = new ElementKind('SETTER', 26, "setter");
 
-  static final ElementKind SETTER = new ElementKind('SETTER', 27, "setter");
+  static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 27, "top level variable");
 
-  static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 28, "top level variable");
+  static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 28, "function type alias");
 
-  static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 29, "function type alias");
+  static final ElementKind TYPE_PARAMETER = new ElementKind('TYPE_PARAMETER', 29, "type parameter");
 
-  static final ElementKind TYPE_PARAMETER = new ElementKind('TYPE_PARAMETER', 30, "type parameter");
-
-  static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 31, "<universe>");
+  static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 30, "<universe>");
 
   static final List<ElementKind> values = [
       ANGULAR_FILTER,
       ANGULAR_COMPONENT,
       ANGULAR_CONTROLLER,
       ANGULAR_DIRECTIVE,
-      ANGULAR_MODULE,
       ANGULAR_PROPERTY,
       ANGULAR_SELECTOR,
       CLASS,
       COMPILATION_UNIT,
       CONSTRUCTOR,
       DYNAMIC,
       EMBEDDED_HTML_SCRIPT,
       ERROR,
       EXPORT,
       EXTERNAL_HTML_SCRIPT,
@@ skipping 66 matching lines @@
  */
 abstract class ElementVisitor<R> {
   R visitAngularComponentElement(AngularComponentElement element);
 
   R visitAngularControllerElement(AngularControllerElement element);
 
   R visitAngularDirectiveElement(AngularDirectiveElement element);
 
   R visitAngularFilterElement(AngularFilterElement element);
 
-  R visitAngularModuleElement(AngularModuleElement element);
-
   R visitAngularPropertyElement(AngularPropertyElement element);
 
   R visitAngularSelectorElement(AngularSelectorElement element);
 
   R visitClassElement(ClassElement element);
 
   R visitCompilationUnitElement(CompilationUnitElement element);
 
   R visitConstructorElement(ConstructorElement element);
 
@@ skipping 441 matching lines @@
   /**
    * Return the class defined in this library that has the given name, or `null` if this
    * library does not define a class with the given name.
    *
    * @param className the name of the class to be returned
    * @return the class with the given name that is defined in this library
    */
   ClassElement getType(String className);
 
   /**
+   * Return an array containing all of the compilation units this library consists of. This includes
+   * the defining compilation unit and units included using the `part` directive.
+   *
+   * @return the compilation units this library consists of
+   */
+  List<CompilationUnitElement> get units;
+
+  /**
    * Return an array containing all directly and indirectly imported libraries.
    *
    * @return all directly and indirectly imported libraries
    */
   List<LibraryElement> get visibleLibraries;
 
   /**
+   * Return `true` if the defining compilation unit of this library contains at least one
+   * import directive whose URI uses the "dart-ext" scheme.
+   */
+  bool hasExtUri();
+
+  /**
    * Answer `true` if this library is an application that can be run in the browser.
    *
    * @return `true` if this library is an application that can be run in the browser
    */
   bool get isBrowserApplication;
 
   /**
    * Return `true` if this library is the dart:core library.
    *
    * @return `true` if this library is the dart:core library
@@ skipping 471 matching lines @@
   String get styleUri;
 
   /**
    * Return the offset of the [getStyleUri] in the [getSource].
    *
    * @return the offset of the style URI
    */
   int get styleUriOffset;
 
   /**
+   * 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;
@@ skipping 21 matching lines @@
   List<AngularPropertyElement> get properties;
 }
 
 /**
  * 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);
 }
 
 /**
  * The interface `AngularFilterElement` defines the Angular filter described by
  * <code>NgFilter</code> annotation.
  *
  * @coverage dart.engine.element
  */
 abstract class AngularFilterElement implements AngularElement {
 }
 
 /**
  * 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 `AngularModuleElement` defines a single DI <code>Module</code>.
- *
- * @coverage dart.engine.element
- */
-abstract class AngularModuleElement implements AngularElement {
-  /**
-   * An empty array of module elements.
-   */
-  static final List<AngularModuleElement> EMPTY_ARRAY = [];
-
-  /**
-   * Returns the child modules installed into this module using <code>install</code>.
-   *
-   * @return the installed child modules
-   */
-  List<AngularModuleElement> get childModules;
-
-  /**
-   * Returns the keys injected into this module using <code>type()</code> and <code>value()</code>
-   * invocations.
-   *
-   * @return the injected types
-   */
-  List<ClassElement> get keyTypes;
-}
-
-/**
  * 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 = [];
@@ skipping 159 matching lines @@
   R visitAngularControllerElement(AngularControllerElement element) => visitAngularHasSelectorElement(element);
 
   R visitAngularDirectiveElement(AngularDirectiveElement element) => visitAngularHasSelectorElement(element);
 
   R visitAngularElement(AngularElement element) => visitToolkitObjectElement(element);
 
   R visitAngularFilterElement(AngularFilterElement element) => visitAngularElement(element);
 
   R visitAngularHasSelectorElement(AngularHasSelectorElement element) => visitAngularElement(element);
 
-  R visitAngularModuleElement(AngularModuleElement element) => visitAngularElement(element);
-
   R visitAngularPropertyElement(AngularPropertyElement element) => visitAngularElement(element);
 
   R visitAngularSelectorElement(AngularSelectorElement element) => visitAngularElement(element);
 
   R visitClassElement(ClassElement element) => visitElement(element);
 
   R visitCompilationUnitElement(CompilationUnitElement element) => visitElement(element);
 
   R visitConstructorElement(ConstructorElement element) => visitExecutableElement(element);
 
@@ skipping 88 matching lines @@
   R visitAngularDirectiveElement(AngularDirectiveElement element) {
     element.visitChildren(this);
     return null;
   }
 
   R visitAngularFilterElement(AngularFilterElement element) {
     element.visitChildren(this);
     return null;
   }
 
-  R visitAngularModuleElement(AngularModuleElement element) {
-    element.visitChildren(this);
-    return null;
-  }
-
   R visitAngularPropertyElement(AngularPropertyElement element) {
     element.visitChildren(this);
     return null;
   }
 
   R visitAngularSelectorElement(AngularSelectorElement element) {
     element.visitChildren(this);
     return null;
   }
 
@@ skipping 118 matching lines @@
  */
 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;
 
-  R visitAngularModuleElement(AngularModuleElement element) => null;
-
   R visitAngularPropertyElement(AngularPropertyElement element) => null;
 
   R visitAngularSelectorElement(AngularSelectorElement element) => null;
 
   R visitClassElement(ClassElement element) => null;
 
   R visitCompilationUnitElement(CompilationUnitElement element) => null;
 
   R visitConstructorElement(ConstructorElement element) => null;
 
@@ skipping 220 matching lines @@
       }
     }
     return null;
   }
 
   ClassDeclaration get node => getNode2(ClassDeclaration);
 
   PropertyAccessorElement getSetter(String setterName) {
     // TODO (jwren) revisit- should we append '=' here or require clients to include it?
     // Do we need the check for isSetter below?
-    if (!setterName.endsWith("=")) {
+    if (!StringUtilities.endsWithChar(setterName, 0x3D)) {
       setterName += '=';
     }
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
 
@@ skipping 528 matching lines @@
     return ToolkitObjectElement.EMPTY_ARRAY;
   }
 
   /**
    * Sets the toolkit objects that are associated with the given [Element].
    *
    * @param element the [Element] to associate toolkit objects with
    * @param objects the toolkit objects to associate
    */
   void setToolkitObjects(Element element, List<ToolkitObjectElement> objects) {
-    for (ToolkitObjectElement toolkitObject in objects) {
-      (toolkitObject as ToolkitObjectElementImpl).enclosingElement = element;
-    }
     _toolkitObjects[element] = objects;
   }
 }
 
 /**
  * Instances of the class `ConstFieldElementImpl` implement a `FieldElement` for a
  * 'const' field that has an initializer.
  */
 class ConstFieldElementImpl extends FieldElementImpl {
   /**
@@ skipping 1486 matching lines @@
   /**
    * Initialize a newly created HTML element to have the given name.
    *
    * @param context the analysis context in which the HTML file is defined
    * @param name the name of this element
    */
   HtmlElementImpl(this.context, String name) : super.con2(name, -1);
 
   accept(ElementVisitor visitor) => visitor.visitHtmlElement(this);
 
-  bool operator ==(Object object) => runtimeType == object.runtimeType && source == (object as CompilationUnitElementImpl).source;
+  bool operator ==(Object object) {
+    if (identical(object, this)) {
+      return true;
+    }
+    if (object == null) {
+      return false;
+    }
+    return runtimeType == object.runtimeType && source == (object as HtmlElementImpl).source;
+  }
 
   ElementKind get kind => ElementKind.HTML;
 
   List<HtmlScriptElement> get scripts => _scripts;
 
   int get hashCode => source.hashCode;
 
   /**
    * Set the scripts contained in the HTML file to the given scripts.
    *
@@ skipping 334 matching lines @@
     }
     for (CompilationUnitElement part in _parts) {
       type = part.getType(className);
       if (type != null) {
         return type;
       }
     }
     return null;
   }
 
+  List<CompilationUnitElement> get units {
+    List<CompilationUnitElement> units = new List<CompilationUnitElement>(1 + _parts.length);
+    units[0] = _definingCompilationUnit;
+    JavaSystem.arraycopy(_parts, 0, units, 1, _parts.length);
+    return units;
+  }
+
   List<LibraryElement> get visibleLibraries {
     Set<LibraryElement> visibleLibraries = new Set();
     addVisibleLibraries(visibleLibraries, false);
     return new List.from(visibleLibraries);
   }
 
+  bool hasExtUri() => hasModifier(Modifier.HAS_EXT_URI);
+
   int get hashCode => _definingCompilationUnit.hashCode;
 
   bool get isBrowserApplication => entryPoint != null && isOrImportsBrowserLibrary;
 
   bool get isDartCore => name == "dart.core";
 
-  bool get isInSdk => name.startsWith("dart.");
+  bool get isInSdk => StringUtilities.startsWith5(name, 0, 0x64, 0x61, 0x72, 0x74, 0x2E);
 
   bool isUpToDate2(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
     return isUpToDate(this, timeStamp, visitedLibraries);
   }
 
   /**
    * Set the compilation unit that defines this library to the given compilation unit.
    *
    * @param definingCompilationUnit the compilation unit that defines this library
    */
   void set definingCompilationUnit(CompilationUnitElement definingCompilationUnit) {
     (definingCompilationUnit as CompilationUnitElementImpl).enclosingElement = this;
     this._definingCompilationUnit = definingCompilationUnit;
   }
 
   /**
    * Set the specifications of all of the exports defined in this library to the given array.
    *
    * @param exports the specifications of all of the exports defined in this library
    */
   void set exports(List<ExportElement> exports) {
     for (ExportElement exportElement in exports) {
       (exportElement as ExportElementImpl).enclosingElement = this;
     }
     this._exports = exports;
   }
 
   /**
+   * Set whether this library has an import of a "dart-ext" URI to the given value.
+   *
+   * @param hasExtUri `true` if this library has an import of a "dart-ext" URI
+   */
+  void set hasExtUri2(bool hasExtUri) {

[Brian Wilkerson, 2014/01/27 22:58:27]

For future consideration: I'm not sure how often I've used this pattern (the
getter is named 'foo' and the setter is named 'setFoo'; usually only with
boolean properties whose names start with 'is' or 'has' or something similar),
but it would be nice if we could translate them into a getter/setter pair with
the same names.

+    setModifier(Modifier.HAS_EXT_URI, hasExtUri);
+  }
+
+  /**
    * Set the specifications of all of the imports defined in this library to the given array.
    *
    * @param imports the specifications of all of the imports defined in this library
    */
   void set imports(List<ImportElement> imports) {
     for (ImportElement importElement in imports) {
       (importElement as ImportElementImpl).enclosingElement = this;
       PrefixElementImpl prefix = importElement.prefix as PrefixElementImpl;
       if (prefix != null) {
         prefix.enclosingElement = this;
@@ skipping 276 matching lines @@
   }
 }
 
 /**
  * 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.
+   */
   static final Modifier CONST = new Modifier('CONST', 1);
 
+  /**
+   * Indicates that the modifier 'factory' was applied to the element.
+   */
   static final Modifier FACTORY = new Modifier('FACTORY', 2);
 
+  /**
+   * Indicates that the modifier 'final' was applied to the element.
+   */
   static final Modifier FINAL = new Modifier('FINAL', 3);
 
+  /**
+   * Indicates that the pseudo-modifier 'get' was applied to the element.
+   */
   static final Modifier GETTER = new Modifier('GETTER', 4);
 
-  static final Modifier MIXIN = new Modifier('MIXIN', 5);
+  /**
+   * A flag used for libraries indicating that the defining compilation unit contains at least one
+   * import directive whose URI uses the "dart-ext" scheme.
+   */
+  static final Modifier HAS_EXT_URI = new Modifier('HAS_EXT_URI', 5);
 
-  static final Modifier REFERENCES_SUPER = new Modifier('REFERENCES_SUPER', 6);
+  static final Modifier MIXIN = new Modifier('MIXIN', 6);
 
-  static final Modifier SETTER = new Modifier('SETTER', 7);
+  static final Modifier REFERENCES_SUPER = new Modifier('REFERENCES_SUPER', 7);
 
-  static final Modifier STATIC = new Modifier('STATIC', 8);
+  /**
+   * Indicates that the pseudo-modifier 'set' was applied to the element.
+   */
+  static final Modifier SETTER = new Modifier('SETTER', 8);
 
-  static final Modifier SYNTHETIC = new Modifier('SYNTHETIC', 9);
+  /**
+   * Indicates that the modifier 'static' was applied to the element.
+   */
+  static final Modifier STATIC = new Modifier('STATIC', 9);
 
-  static final Modifier TYPEDEF = new Modifier('TYPEDEF', 10);
+  /**
+   * Indicates that the element does not appear in the source code but was implicitly created. For
+   * example, if a class does not define any constructors, an implicit zero-argument constructor
+   * will be created and it will be marked as being synthetic.
+   */
+  static final Modifier SYNTHETIC = new Modifier('SYNTHETIC', 10);
+
+  static final Modifier TYPEDEF = new Modifier('TYPEDEF', 11);
 
   static final List<Modifier> values = [
       ABSTRACT,
       CONST,
       FACTORY,
       FINAL,
       GETTER,
+      HAS_EXT_URI,
       MIXIN,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
 
   Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
@@ skipping 829 matching lines @@
    * The offset of the [styleUri] in the [getSource].
    */
   int styleUriOffset = 0;
 
   /**
    * The HTML template URI.
    */
   String templateUri;
 
   /**
+   * The HTML template source.
+   */
+  Source templateSource;
+
+  /**
    * The offset of the [templateUri] in the [getSource].
    */
   int templateUriOffset = 0;
 
   /**
    * Initialize a newly created Angular component 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
@@ skipping 165 matching lines @@
     this._selector = selector;
   }
 
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_selector, visitor);
     super.visitChildren(visitor);
   }
 }
 
 /**
- * Implementation of `AngularModuleElement`.
- *
- * @coverage dart.engine.element
- */
-class AngularModuleElementImpl extends AngularElementImpl implements AngularModuleElement {
-  /**
-   * The array containing all of the child modules.
-   */
-  List<AngularModuleElement> childModules = AngularModuleElement.EMPTY_ARRAY;
-
-  /**
-   * The array containing all of the types used as injection keys.
-   */
-  List<ClassElement> keyTypes = ClassElementImpl.EMPTY_ARRAY;
-
-  /**
-   * Initialize a newly created Angular module.
-   */
-  AngularModuleElementImpl() : super(null, -1);
-
-  accept(ElementVisitor visitor) => visitor.visitAngularModuleElement(this);
-
-  ElementKind get kind => ElementKind.ANGULAR_MODULE;
-}
-
-/**
  * Implementation of `AngularPropertyElement`.
  *
  * @coverage dart.engine.element
  */
 class AngularPropertyElementImpl extends AngularElementImpl implements AngularPropertyElement {
   /**
    * The [FieldElement] to which this property is bound.
    */
   FieldElement field;
 
@@ skipping 3118 matching lines @@
 
 /**
  * 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);
 }