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';
 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 XmlTagNode;
+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 {
@@ skipping 121 matching lines @@
    * <b>Note:</b> Because the element model represents the state of the code, it is possible for it
    * to be semantically invalid. In particular, it is not safe to assume that the inheritance
    * structure of a class does not contain a cycle. Clients that traverse the inheritance structure
    * must explicitly guard against infinite loops.
    *
    * @return the superclass of this class
    */
   InterfaceType get supertype;
 
   /**
-   * Return an array containing all of the toolkit specific objects attached to this class.
+   * Return an array containing all of the toolkit specific objects associated with this class. The
+   * array will be empty if the class does not have any toolkit specific objects or if the
+   * compilation unit containing the class has not yet had toolkit references resolved.
    *
-   * @return the toolkit objects attached to this class
+   * @return the toolkit objects associated with this class
    */
   List<ToolkitObjectElement> get toolkitObjects;
 
   /**
    * Return the type defined by the class.
    *
    * @return the type defined by the class
    */
   InterfaceType get type;
 
@@ skipping 32 matching lines @@
   /**
    * Return `true` if this class is abstract. A class is abstract if it has an explicit
    * `abstract` modifier. Note, that this definition of <i>abstract</i> is different from
    * <i>has unimplemented members</i>.
    *
    * @return `true` if this class is abstract
    */
   bool get isAbstract;
 
   /**
+   * Return `true` if this class [isProxy], or if it inherits the proxy annotation
+   * from a supertype.
+   *
+   * @return `true` if this class defines or inherits a proxy
+   */
+  bool get isOrInheritsProxy;
+
+  /**
    * Return `true` if this element has an annotation of the form '@proxy'.
    *
    * @return `true` if this element defines a proxy
    */
   bool get isProxy;
 
   /**
    * Return `true` if this class is defined by a typedef construct.
    *
    * @return `true` if this class is defined by a typedef construct
@@ skipping 108 matching lines @@
 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;
 
   /**
+   * Return an array containing all of the Angular views defined in this compilation unit. The array
+   * will be empty if the element does not have any Angular views or if the compilation unit has not
+   * yet had toolkit references resolved.
+   *
+   * @return the Angular views defined in this compilation unit.
+   */
+  List<AngularViewElement> get angularViews;
+
+  /**
    * Return the library in which this compilation unit is defined.
    *
    * @return the library in which this compilation unit is defined
    */
   LibraryElement get enclosingElement;
 
   /**
    * Return an array containing all of the top-level functions contained in this compilation unit.
    *
    * @return the top-level functions contained in this compilation unit
@@ skipping 53 matching lines @@
    * [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`.
    */
   ConstructorDeclaration get node;
 
   /**
-   * Return the constructor to which this constructor is redirecting.
+   * Return the constructor to which this constructor is redirecting, or `null` if this constructor
+   * does not redirect to another constructor or if the library containing this constructor has
+   * not yet been resolved.
    *
    * @return the constructor to which this constructor is redirecting
    */
   ConstructorElement get redirectedConstructor;
 
   /**
    * Return `true` if this constructor is a const constructor.
    *
    * @return `true` if this constructor is a const constructor
    */
@@ skipping 122 matching lines @@
 
   /**
    * Return an object representing the location of this element in the element model. The object can
    * be used to locate this element at a later time.
    *
    * @return the location of this element in the element model
    */
   ElementLocation get location;
 
   /**
-   * Return an array containing all of the metadata associated with this element.
+   * Return an array containing all of the metadata associated with this element. The array will be
+   * empty if the element does not have any metadata or if the library containing this element has
+   * not yet been resolved.
    *
    * @return the metadata associated with this element
    */
   List<ElementAnnotation> get metadata;
 
   /**
    * Return the name of this element, or `null` if this element does not have a name.
    *
    * @return the name of this element
    */
@@ skipping 50 matching lines @@
 
   /**
    * Return `true` if this element has an annotation of the form '@deprecated' or
    * '@Deprecated('..')'.
    *
    * @return `true` if this element is deprecated
    */
   bool get isDeprecated;
 
   /**
+   * Return `true` if this element has an annotation of the form '@override'.
+   *
+   * @return `true` if this element is overridden
+   */
+  bool get isOverride;
+
+  /**
    * Return `true` if this element is private. Private elements are visible only within the
    * library in which they are declared.
    *
    * @return `true` if this element is private
    */
   bool get isPrivate;
 
   /**
    * Return `true` if this element is public. Public elements are visible within any library
    * that imports the library in which they are declared.
@@ skipping 70 matching lines @@
   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_PROPERTY = new ElementKind('ANGULAR_PROPERTY', 4, "Angular property");
 
-  static final ElementKind ANGULAR_SELECTOR = new ElementKind('ANGULAR_SELECTOR', 5, "Angular selector");
+  static final ElementKind ANGULAR_SCOPE_PROPERTY = new ElementKind('ANGULAR_SCOPE_PROPERTY', 5, "Angular scope property");
 
-  static final ElementKind CLASS = new ElementKind('CLASS', 6, "class");
+  static final ElementKind ANGULAR_SELECTOR = new ElementKind('ANGULAR_SELECTOR', 6, "Angular selector");
 
-  static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 7, "compilation unit");
+  static final ElementKind ANGULAR_VIEW = new ElementKind('ANGULAR_VIEW', 7, "Angular view");
 
-  static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 8, "constructor");
+  static final ElementKind CLASS = new ElementKind('CLASS', 8, "class");
 
-  static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 9, "<dynamic>");
+  static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 9, "compilation unit");
 
-  static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 10, "embedded html script");
+  static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 10, "constructor");
 
-  static final ElementKind ERROR = new ElementKind('ERROR', 11, "<error>");
+  static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 11, "<dynamic>");
 
-  static final ElementKind EXPORT = new ElementKind('EXPORT', 12, "export directive");
+  static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 12, "embedded html script");
 
-  static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 13, "external html script");
+  static final ElementKind ERROR = new ElementKind('ERROR', 13, "<error>");
 
-  static final ElementKind FIELD = new ElementKind('FIELD', 14, "field");
+  static final ElementKind EXPORT = new ElementKind('EXPORT', 14, "export directive");
 
-  static final ElementKind FUNCTION = new ElementKind('FUNCTION', 15, "function");
+  static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 15, "external html script");
 
-  static final ElementKind GETTER = new ElementKind('GETTER', 16, "getter");
+  static final ElementKind FIELD = new ElementKind('FIELD', 16, "field");
 
-  static final ElementKind HTML = new ElementKind('HTML', 17, "html");
+  static final ElementKind FUNCTION = new ElementKind('FUNCTION', 17, "function");
 
-  static final ElementKind IMPORT = new ElementKind('IMPORT', 18, "import directive");
+  static final ElementKind GETTER = new ElementKind('GETTER', 18, "getter");
 
-  static final ElementKind LABEL = new ElementKind('LABEL', 19, "label");
+  static final ElementKind HTML = new ElementKind('HTML', 19, "html");
 
-  static final ElementKind LIBRARY = new ElementKind('LIBRARY', 20, "library");
+  static final ElementKind IMPORT = new ElementKind('IMPORT', 20, "import directive");
 
-  static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 21, "local variable");
+  static final ElementKind LABEL = new ElementKind('LABEL', 21, "label");
 
-  static final ElementKind METHOD = new ElementKind('METHOD', 22, "method");
+  static final ElementKind LIBRARY = new ElementKind('LIBRARY', 22, "library");
 
-  static final ElementKind NAME = new ElementKind('NAME', 23, "<name>");
+  static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 23, "local variable");
 
-  static final ElementKind PARAMETER = new ElementKind('PARAMETER', 24, "parameter");
+  static final ElementKind METHOD = new ElementKind('METHOD', 24, "method");
 
-  static final ElementKind PREFIX = new ElementKind('PREFIX', 25, "import prefix");
+  static final ElementKind NAME = new ElementKind('NAME', 25, "<name>");
 
-  static final ElementKind SETTER = new ElementKind('SETTER', 26, "setter");
+  static final ElementKind PARAMETER = new ElementKind('PARAMETER', 26, "parameter");
 
-  static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 27, "top level variable");
+  static final ElementKind PREFIX = new ElementKind('PREFIX', 27, "import prefix");
 
-  static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 28, "function type alias");
+  static final ElementKind SETTER = new ElementKind('SETTER', 28, "setter");
 
-  static final ElementKind TYPE_PARAMETER = new ElementKind('TYPE_PARAMETER', 29, "type parameter");
+  static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 29, "top level variable");
 
-  static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 30, "<universe>");
+  static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 30, "function type alias");
+
+  static final ElementKind TYPE_PARAMETER = new ElementKind('TYPE_PARAMETER', 31, "type parameter");
+
+  static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 32, "<universe>");
 
   static final List<ElementKind> values = [
       ANGULAR_FILTER,
       ANGULAR_COMPONENT,
       ANGULAR_CONTROLLER,
       ANGULAR_DIRECTIVE,
       ANGULAR_PROPERTY,
+      ANGULAR_SCOPE_PROPERTY,
       ANGULAR_SELECTOR,
+      ANGULAR_VIEW,
       CLASS,
       COMPILATION_UNIT,
       CONSTRUCTOR,
       DYNAMIC,
       EMBEDDED_HTML_SCRIPT,
       ERROR,
       EXPORT,
       EXTERNAL_HTML_SCRIPT,
       FIELD,
       FUNCTION,
@@ skipping 66 matching lines @@
   R visitAngularComponentElement(AngularComponentElement element);
 
   R visitAngularControllerElement(AngularControllerElement element);
 
   R visitAngularDirectiveElement(AngularDirectiveElement element);
 
   R visitAngularFilterElement(AngularFilterElement element);
 
   R visitAngularPropertyElement(AngularPropertyElement element);
 
+  R visitAngularScopePropertyElement(AngularScopePropertyElement element);
+
   R visitAngularSelectorElement(AngularSelectorElement element);
 
+  R visitAngularViewElement(AngularViewElement element);
+
   R visitClassElement(ClassElement element);
 
   R visitCompilationUnitElement(CompilationUnitElement element);
 
   R visitConstructorElement(ConstructorElement element);
 
   R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element);
 
   R visitExportElement(ExportElement element);
 
@@ skipping 464 matching lines @@
    */
   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();
 
   /**
-   * Return `true` if this library is created for Angular analysis.
+   * Return `true` if this library is created for Angular analysis. If this library has not
+   * yet had toolkit references resolved, then `false` will be returned.
    *
    * @return `true` if this library is created for Angular analysis
    */
   bool get isAngularHtml;
 
   /**
    * 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
    */
@@ skipping 111 matching lines @@
 
   /**
    * 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);
@@ skipping 327 matching lines @@
    */
   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 {
+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;
-
-  /**
-   * 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 `AngularControllerElement` defines the Angular controller described by
  * <code>NgController</code> annotation.
  *
  * @coverage dart.engine.element
  */
 abstract class AngularControllerElement implements AngularHasSelectorElement {
 }
@@ skipping 20 matching lines @@
  * 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.
    *
    * @return the field this property is mapped to.
    */
   FieldElement get field;
 
   /**
-   * Return the offset of the field name of this property in the property map.
+   * Return the offset of the field name of this property in the property map, or `-1` if
+   * property was created using annotation on [FieldElement].
    *
    * @return the offset of the field name of this property
    */
   int get fieldNameOffset;
 
   /**
    * Returns the kind of this property.
    *
    * @return the kind of this property
    */
@@ skipping 54 matching lines @@
   AngularPropertyKind(String name, int ordinal) : super(name, ordinal);
 }
 
 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>.
+   *
+   * @return the type of this property.
+   */
+  Type2 get type;
+}
+
+/**
  * [AngularSelectorElement] is used to decide when Angular object should be applied.
  *
  * This class is an [Element] to support renaming component tag names, which are identifiers
  * in selectors.
  */
 abstract class AngularSelectorElement implements AngularElement {
   /**
    * Checks if the given [XmlTagNode] matches this selector.
    *
    * @param node the [XmlTagNode] to check
    * @return `true` if the given [XmlTagNode] matches, or `false` otherwise
    */
   bool apply(XmlTagNode node);
 }
 
 /**
+ * [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
  * recursively visit all of the elements in an element model (like instances of the class
  * [RecursiveElementVisitor]). In addition, when an element of a specific type is visited not
  * only will the visit method for that specific type of element be invoked, but additional methods
  * for the supertypes of that element will also be invoked. For example, using an instance of this
  * class to visit a [MethodElement] will cause the method
  * [visitMethodElement] to be invoked but will also cause the methods
  * [visitExecutableElement] and [visitElement] to be
  * subsequently invoked. This allows visitors to be written that visit all executable elements
  * without needing to override the visit method for each of the specific subclasses of
@@ skipping 51 matching lines @@
   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 visitAngularPropertyElement(AngularPropertyElement element) => visitAngularElement(element);
 
+  R visitAngularScopePropertyElement(AngularScopePropertyElement element) => visitAngularElement(element);
+
   R visitAngularSelectorElement(AngularSelectorElement element) => visitAngularElement(element);
 
+  R visitAngularViewElement(AngularViewElement element) => visitAngularElement(element);
+
   R visitClassElement(ClassElement element) => visitElement(element);
 
   R visitCompilationUnitElement(CompilationUnitElement element) => visitElement(element);
 
   R visitConstructorElement(ConstructorElement element) => visitExecutableElement(element);
 
   R visitElement(Element element) {
     element.visitChildren(this);
     return null;
   }
@@ skipping 89 matching lines @@
   R visitAngularFilterElement(AngularFilterElement element) {
     element.visitChildren(this);
     return null;
   }
 
   R visitAngularPropertyElement(AngularPropertyElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  R visitAngularScopePropertyElement(AngularScopePropertyElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+
   R visitAngularSelectorElement(AngularSelectorElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  R visitAngularViewElement(AngularViewElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+
   R visitClassElement(ClassElement element) {
     element.visitChildren(this);
     return null;
   }
 
   R visitCompilationUnitElement(CompilationUnitElement element) {
     element.visitChildren(this);
     return null;
   }
 
@@ skipping 110 matching lines @@
   R visitAngularComponentElement(AngularComponentElement element) => null;
 
   R visitAngularControllerElement(AngularControllerElement element) => null;
 
   R visitAngularDirectiveElement(AngularDirectiveElement element) => null;
 
   R visitAngularFilterElement(AngularFilterElement element) => null;
 
   R visitAngularPropertyElement(AngularPropertyElement element) => null;
 
+  R visitAngularScopePropertyElement(AngularScopePropertyElement element) => null;
+
   R visitAngularSelectorElement(AngularSelectorElement element) => null;
 
+  R visitAngularViewElement(AngularViewElement element) => null;
+
   R visitClassElement(ClassElement element) => null;
 
   R visitCompilationUnitElement(CompilationUnitElement element) => null;
 
   R visitConstructorElement(ConstructorElement element) => null;
 
   R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element) => null;
 
   R visitExportElement(ExportElement element) => null;
 
@@ skipping 112 matching lines @@
    * The type defined by the class.
    */
   InterfaceType type;
 
   /**
    * An array containing all of the type parameters defined for this class.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElementImpl.EMPTY_ARRAY;
 
   /**
-   * An empty array of type elements.
+   * An empty array of class elements.
    */
   static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
 
   /**
    * Initialize a newly created class element to have the given name.
    *
    * @param name the name of this element
    */
   ClassElementImpl(Identifier name) : super.con1(name);
 
@@ skipping 144 matching lines @@
       }
     }
     // not found
     return false;
   }
 
   bool hasReferenceToSuper() => hasModifier(Modifier.REFERENCES_SUPER);
 
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
+  bool get isOrInheritsProxy => isOrInheritsProxy2(this, new Set<ClassElement>());
+
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isProxy) {
         return true;
       }
     }
     return false;
   }
 
   bool get isTypedef => hasModifier(Modifier.TYPEDEF);
@@ skipping 240 matching lines @@
         }
         for (InterfaceType type in currentElement.mixins) {
           ClassElement element = type.element;
           if (!visitedClasses.contains(element)) {
             supertypes.add(type);
           }
         }
       }
     }
   }
+
+  bool isOrInheritsProxy2(ClassElement classElt, Set<ClassElement> visitedClassElts) {
+    if (visitedClassElts.contains(classElt)) {
+      return false;
+    }
+    visitedClassElts.add(classElt);
+    if (classElt.isProxy) {
+      return true;
+    } else if (classElt.supertype != null && isOrInheritsProxy2(classElt.supertype.element, visitedClassElts)) {
+      return true;
+    }
+    List<InterfaceType> supertypes = classElt.interfaces;
+    for (int i = 0; i < supertypes.length; i++) {
+      if (isOrInheritsProxy2(supertypes[i].element, visitedClassElts)) {
+        return true;
+      }
+    }
+    supertypes = classElt.mixins;
+    for (int i = 0; i < supertypes.length; i++) {
+      if (isOrInheritsProxy2(supertypes[i].element, visitedClassElts)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }
 
 /**
  * Instances of the class `CompilationUnitElementImpl` implement a
  * [CompilationUnitElement].
  *
  * @coverage dart.engine.element
  */
 class CompilationUnitElementImpl extends ElementImpl implements CompilationUnitElement {
   /**
@@ skipping 37 matching lines @@
    */
   List<TopLevelVariableElement> _variables = TopLevelVariableElementImpl.EMPTY_ARRAY;
 
   /**
    * The URI that is specified by the "part" directive in the enclosing library, or `null` if
    * this is the defining compilation unit of a library.
    */
   String uri;
 
   /**
+   * An array containing all of the Angular views contained in this compilation unit.
+   */
+  List<AngularViewElement> _angularViews = AngularViewElement.EMPTY_ARRAY;
+
+  /**
    * Initialize a newly created compilation unit element to have the given name.
    *
    * @param name the name of this element
    */
   CompilationUnitElementImpl(String name) : super.con2(name, -1);
 
   accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
 
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && source == (object as CompilationUnitElementImpl).source;
 
   List<PropertyAccessorElement> get accessors => _accessors;
 
+  List<AngularViewElement> get angularViews => _angularViews;
+
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have thrown a CCE if any of
     // the elements in the arrays were not of the expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
@@ skipping 52 matching lines @@
    * @param the top-level accessors (getters and setters) contained in this compilation unit
    */
   void set accessors(List<PropertyAccessorElement> accessors) {
     for (PropertyAccessorElement accessor in accessors) {
       (accessor as PropertyAccessorElementImpl).enclosingElement = this;
     }
     this._accessors = accessors;
   }
 
   /**
+   * Set the Angular views defined in this compilation unit.
+   *
+   * @param angularViews the Angular views defined in this compilation unit
+   */
+  void set angularViews(List<AngularViewElement> angularViews) {
+    for (AngularViewElement view in angularViews) {
+      (view as AngularViewElementImpl).enclosingElement = this;
+    }
+    this._angularViews = angularViews;
+  }
+
+  /**
    * Set the top-level functions contained in this compilation unit to the given functions.
    *
    * @param functions the top-level functions contained in this compilation unit
    */
   void set functions(List<FunctionElement> functions) {
     for (FunctionElement function in functions) {
       (function as FunctionElementImpl).enclosingElement = this;
     }
     this._functions = functions;
   }
@@ skipping 34 matching lines @@
     this._types = types;
   }
 
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
+    safelyVisitChildren(_angularViews, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
     if (source == null) {
       builder.append("{compilation unit}");
     } else {
       builder.append(source.fullName);
     }
   }
 
@@ skipping 112 matching lines @@
   /**
    * The constructor to which this constructor is redirecting.
    */
   ConstructorElement redirectedConstructor;
 
   /**
    * Initialize a newly created constructor element to have the given name.
    *
    * @param name the name of this element
    */
-  ConstructorElementImpl(Identifier name) : super.con1(name);
+  ConstructorElementImpl.con1(Identifier name) : super.con1(name);
+
+  /**
+   * Initialize a newly created constructor 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
+   */
+  ConstructorElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
 
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
   ConstructorDeclaration get node => getNode2(ConstructorDeclaration);
 
   bool get isConst => hasModifier(Modifier.CONST);
@@ skipping 359 matching lines @@
 
   bool get isDeprecated {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isDeprecated) {
         return true;
       }
     }
     return false;
   }
 
+  bool get isOverride {
+    for (ElementAnnotation annotation in metadata) {
+      if (annotation.isOverride) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   bool get isPrivate {
     String name = displayName;
     if (name == null) {
       return true;
     }
     return Identifier.isPrivateName(name);
   }
 
   bool get isPublic => !isPrivate;
 
@@ skipping 1221 matching lines @@
   /**
    * Determine if the given library is up to date with respect to the given time stamp.
    *
    * @param library the library to process
    * @param timeStamp the time stamp to check against
    * @param visitedLibraries the set of visited libraries
    */
   static bool isUpToDate(LibraryElement library, int timeStamp, Set<LibraryElement> visitedLibraries) {
     if (!visitedLibraries.contains(library)) {
       visitedLibraries.add(library);
+      AnalysisContext context = library.context;
       // Check the defining compilation unit.
-      if (timeStamp < library.definingCompilationUnit.source.modificationStamp) {
+      if (timeStamp < context.getModificationStamp(library.definingCompilationUnit.source)) {
         return false;
       }
       // Check the parted compilation units.
       for (CompilationUnitElement element in library.parts) {
-        if (timeStamp < element.source.modificationStamp) {
+        if (timeStamp < context.getModificationStamp(element.source)) {
           return false;
         }
       }
       // Check the imported libraries.
       for (LibraryElement importedLibrary in library.importedLibraries) {
         if (!isUpToDate(importedLibrary, timeStamp, visitedLibraries)) {
           return false;
         }
       }
       // Check the exported libraries.
@@ skipping 695 matching lines @@
     for (Element element in conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
 
   bool get isDeprecated => false;
 
+  bool get isOverride => false;
+
   bool get isPrivate {
     String name = displayName;
     if (name == null) {
       return false;
     }
     return Identifier.isPrivateName(name);
   }
 
   bool get isPublic => !isPrivate;
 
@@ skipping 11 matching lines @@
     }
     builder.append("]");
     return builder.toString();
   }
 
   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;
 
@@ skipping 142 matching lines @@
   void appendTo(JavaStringBuilder builder) {
     String left = "";
     String right = "";
     while (true) {
       if (parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
+      } else if (parameterKind == ParameterKind.REQUIRED) {
       }
       break;
     }
     builder.append(left);
     appendToWithoutDelimiters(builder);
     builder.append(right);
   }
 
   /**
    * Append the type and name of this parameter to the given builder.
@@ skipping 392 matching lines @@
    * Initialize a newly created variable element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   VariableElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
 
   /**
    * Return the result of evaluating this variable's initializer as a compile-time constant
-   * expression, or `null` if this variable is not a 'const' variable or does not have an
-   * initializer.
+   * expression, or `null` if this variable is not a 'const' variable, if it does not have an
+   * initializer, or if the compilation unit containing the variable has not been resolved.
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
 
   FunctionElement get initializer => _initializer;
 
   VariableDeclaration get node => getNode2(VariableDeclaration);
 
   bool get isConst => hasModifier(Modifier.CONST);
 
   bool get isFinal => hasModifier(Modifier.FINAL);
 
   /**
-   * Return `true` if this variable is potentially mutated somewhere in closure. This
-   * information is only available for local variables (including parameters).
+   * Return `true` if this variable is potentially mutated somewhere in a closure. This
+   * information is only available for local variables (including parameters) and only after the
+   * compilation unit containing the variable has been resolved.
    *
    * @return `true` if this variable is potentially mutated somewhere in closure
    */
   bool get isPotentiallyMutatedInClosure => false;
 
   /**
    * Return `true` if this variable is potentially mutated somewhere in its scope. This
-   * information is only available for local variables (including parameters).
+   * information is only available for local variables (including parameters) and only after the
+   * compilation unit containing the variable has been resolved.
    *
    * @return `true` if this variable is potentially mutated somewhere in its scope
    */
   bool get isPotentiallyMutatedInScope => false;
 
   /**
    * Set whether this variable is const to correspond to the given value.
    *
    * @param isConst `true` if the variable is const
    */
@@ skipping 38 matching lines @@
   }
 
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 }
 
 /**
+ * Information about Angular application.
+ */
+class AngularApplication {
+  final Source entryPoint;
+
+  Set<Source> _librarySources;
+
+  final List<AngularElement> elements;
+
+  final List<Source> elementSources;
+
+  AngularApplication(this.entryPoint, Set<Source> librarySources, this.elements, this.elementSources) {
+    this._librarySources = librarySources;
+  }
+
+  /**
+   * 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.
    */
   List<AngularPropertyElement> _properties = AngularPropertyElement.EMPTY_ARRAY;
 
   /**
+   * The array containing all of the scope properties set by this component.
+   */
+  List<AngularScopePropertyElement> _scopeProperties = AngularScopePropertyElement.EMPTY_ARRAY;
+
+  /**
    * The the CSS file URI.
    */
   String styleUri;
 
   /**
    * The offset of the [styleUri] in the [getSource].
    */
   int styleUriOffset = 0;
 
   /**
@@ skipping 21 matching lines @@
   AngularComponentElementImpl(String name, int nameOffset, int annotationOffset) : super(name, nameOffset) {
     this._annotationOffset = annotationOffset;
   }
 
   accept(ElementVisitor visitor) => visitor.visitAngularComponentElement(this);
 
   ElementKind get kind => ElementKind.ANGULAR_COMPONENT;
 
   List<AngularPropertyElement> get properties => _properties;
 
+  List<AngularScopePropertyElement> get scopeProperties => _scopeProperties;
+
   /**
    * Set an array containing all of the properties declared by this component.
    *
    * @param properties the properties to set
    */
   void set properties(List<AngularPropertyElement> properties) {
     for (AngularPropertyElement property in properties) {
       encloseElement(property as AngularPropertyElementImpl);
     }
     this._properties = properties;
   }
 
+  /**
+   * Set an array containing all of the scope properties declared by this component.
+   *
+   * @param properties the properties to set
+   */
+  void set scopeProperties(List<AngularScopePropertyElement> properties) {
+    for (AngularScopePropertyElement property in properties) {
+      encloseElement(property as AngularScopePropertyElementImpl);
+    }
+    this._scopeProperties = properties;
+  }
+
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChildren(_properties, visitor);
+    safelyVisitChildren(_scopeProperties, visitor);
     super.visitChildren(visitor);
   }
 
   String get identifier => "AngularComponent@${_annotationOffset}";
 }
 
 /**
  * Implementation of `AngularControllerElement`.
  *
  * @coverage dart.engine.element
@@ skipping 71 matching lines @@
   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);
 
   accept(ElementVisitor visitor) => visitor.visitAngularFilterElement(this);
 
   ElementKind get kind => ElementKind.ANGULAR_FILTER;
 }
 
 /**
+ * Implementation of [AngularSelectorElement] based on presence of a class.
+ */
+class AngularHasClassSelectorElementImpl extends AngularSelectorElementImpl implements AngularHasClassSelectorElement {
+  AngularHasClassSelectorElementImpl(String name, int offset) : super(name, offset);
+
+  bool apply(XmlTagNode node) {
+    XmlAttributeNode attribute = node.getAttribute("class");
+    if (attribute != null) {
+      String text = attribute.text;
+      if (text != null) {
+        String name = this.name;
+        for (String className in StringUtils.split(text)) {
+          if (className == name) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  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;
 
@@ skipping 50 matching lines @@
    *          declaration of this element
    */
   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);
 
   accept(ElementVisitor visitor) => visitor.visitAngularSelectorElement(this);
 
   ElementKind get kind => ElementKind.ANGULAR_SELECTOR;
 }
 
 /**
+ * Implementation of [AngularSelectorElement] based on tag name.
+ */
+class AngularTagSelectorElementImpl extends AngularSelectorElementImpl implements AngularTagSelectorElement {
+  AngularTagSelectorElementImpl(String name, int offset) : super(name, offset);
+
+  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].
+   */
+  final int templateUriOffset;
+
+  /**
+   * The HTML template source.
+   */
+  Source templateSource;
+
+  /**
+   * Initialize a newly created Angular view.
+   */
+  AngularViewElementImpl(this.templateUri, this.templateUriOffset) : super(null, -1);
+
+  accept(ElementVisitor visitor) => visitor.visitAngularViewElement(this);
+
+  ElementKind get kind => ElementKind.ANGULAR_VIEW;
+
+  String get identifier => "AngularView@${templateUriOffset}";
+}
+
+/**
  * Implementation of [AngularSelectorElement] based on presence of attribute.
  */
-class HasAttributeSelectorElementImpl extends AngularSelectorElementImpl {
+class HasAttributeSelectorElementImpl extends AngularSelectorElementImpl implements AngularHasAttributeSelectorElement {
   HasAttributeSelectorElementImpl(String attributeName, int offset) : super(attributeName, offset);
 
   bool apply(XmlTagNode node) {
     String attributeName = name;
     return node.getAttribute(attributeName) != null;
   }
 
-  String get displayName => "[${super.displayName}]";
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("[");
+    builder.append(name);
+    builder.append("]");
+  }
 }
 
 /**
- * Combination of [IsTagSelectorElementImpl] and [HasAttributeSelectorElementImpl].
+ * Combination of [AngularTagSelectorElementImpl] and [HasAttributeSelectorElementImpl].
  */
 class IsTagHasAttributeSelectorElementImpl extends AngularSelectorElementImpl {
   final String tagName;
 
   final String attributeName;
 
   IsTagHasAttributeSelectorElementImpl(this.tagName, this.attributeName) : super(null, -1);
 
   bool apply(XmlTagNode node) => node.tag == tagName && node.getAttribute(attributeName) != null;
 }
 
 /**
- * Implementation of [AngularSelectorElement] based on tag name.
- */
-class IsTagSelectorElementImpl extends AngularSelectorElementImpl {
-  IsTagSelectorElementImpl(String name, int offset) : super(name, offset);
-
-  bool apply(XmlTagNode node) {
-    String tagName = name;
-    return node.tag == tagName;
-  }
-}
-
-/**
  * Instances of the class `ConstructorMember` represent a constructor element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ConstructorMember extends ExecutableMember implements ConstructorElement {
   /**
    * If the given constructor's type is different when any type parameters from the defining type's
    * declaration are replaced with the actual type arguments from the defining type, create a
    * constructor member representing the given constructor. Return the member that was created, or
    * the base constructor if no member was created.
    *
@@ skipping 273 matching lines @@
   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;
+
   bool get isPrivate => _baseElement.isPrivate;
 
   bool get isPublic => _baseElement.isPublic;
 
   bool get isSynthetic => _baseElement.isSynthetic;
 
   void visitChildren(ElementVisitor visitor) {
   }
 
   /**
@@ skipping 229 matching lines @@
     ParameterElement baseElement = this.baseElement;
     String left = "";
     String right = "";
     while (true) {
       if (baseElement.parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (baseElement.parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
+      } else if (baseElement.parameterKind == ParameterKind.REQUIRED) {
       }
       break;
     }
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(left);
     builder.append(type);
     builder.append(" ");
     builder.append(baseElement.displayName);
     builder.append(right);
     return builder.toString();
@@ skipping 2498 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);
 }