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 XmlAttributeNode, XmlTagNode;
-import 'engine.dart' show AnalysisContext;
+import 'engine.dart' show AnalysisContext, AnalysisEngine, AnalysisException;
 import 'constant.dart' show EvaluationResultImpl;
 import 'utilities_dart.dart';
 
 /**
  * The interface `ClassElement` defines the behavior of elements that represent a class.
  */
 abstract class ClassElement implements Element {
   /**
    * Return an array containing all of the accessors (getters and setters) declared in this class.
    *
@@ skipping 703 matching lines @@
    * @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.
  */
 class ElementKind extends Enum<ElementKind> {
-  static const ElementKind ANGULAR_FILTER = const ElementKind('ANGULAR_FILTER', 0, "Angular filter");
+  static const ElementKind ANGULAR_FORMATTER = const ElementKind('ANGULAR_FORMATTER', 0, "Angular formatter");
 
   static const ElementKind ANGULAR_COMPONENT = const ElementKind('ANGULAR_COMPONENT', 1, "Angular component");
 
   static const ElementKind ANGULAR_CONTROLLER = const ElementKind('ANGULAR_CONTROLLER', 2, "Angular controller");
 
   static const ElementKind ANGULAR_DIRECTIVE = const ElementKind('ANGULAR_DIRECTIVE', 3, "Angular directive");
 
   static const ElementKind ANGULAR_PROPERTY = const ElementKind('ANGULAR_PROPERTY', 4, "Angular property");
 
   static const ElementKind ANGULAR_SCOPE_PROPERTY = const ElementKind('ANGULAR_SCOPE_PROPERTY', 5, "Angular scope property");
@@ skipping 52 matching lines @@
 
   static const ElementKind TOP_LEVEL_VARIABLE = const ElementKind('TOP_LEVEL_VARIABLE', 32, "top level variable");
 
   static const ElementKind FUNCTION_TYPE_ALIAS = const ElementKind('FUNCTION_TYPE_ALIAS', 33, "function type alias");
 
   static const ElementKind TYPE_PARAMETER = const ElementKind('TYPE_PARAMETER', 34, "type parameter");
 
   static const ElementKind UNIVERSE = const ElementKind('UNIVERSE', 35, "<universe>");
 
   static const List<ElementKind> values = const [
-      ANGULAR_FILTER,
+      ANGULAR_FORMATTER,
       ANGULAR_COMPONENT,
       ANGULAR_CONTROLLER,
       ANGULAR_DIRECTIVE,
       ANGULAR_PROPERTY,
       ANGULAR_SCOPE_PROPERTY,
       ANGULAR_SELECTOR,
       ANGULAR_VIEW,
       CLASS,
       COMPILATION_UNIT,
       CONSTRUCTOR,
@@ skipping 66 matching lines @@
 
 /**
  * The interface `ElementVisitor` defines the behavior of objects that can be used to visit an
  * element structure.
  */
 abstract class ElementVisitor<R> {
   R visitAngularComponentElement(AngularComponentElement element);
 
   R visitAngularControllerElement(AngularControllerElement element);
 
-  R visitAngularDirectiveElement(AngularDirectiveElement element);
+  R visitAngularDirectiveElement(AngularDecoratorElement element);
 
-  R visitAngularFilterElement(AngularFilterElement element);
+  R visitAngularFormatterElement(AngularFormatterElement element);
 
   R visitAngularPropertyElement(AngularPropertyElement element);
 
   R visitAngularScopePropertyElement(AngularScopePropertyElement element);
 
   R visitAngularSelectorElement(AngularSelectorElement element);
 
   R visitAngularViewElement(AngularViewElement element);
 
   R visitClassElement(ClassElement element);
@@ skipping 423 matching lines @@
   List<LibraryElement> get importedLibraries;
 
   /**
    * Return an array containing all of the imports defined in this library.
    *
    * @return the imports defined in this library
    */
   List<ImportElement> get imports;
 
   /**
+   * Return an array containing all of the imports that share the given prefix, or an empty array if
+   * there are no such imports.
+   *
+   * @param prefixElement the prefix element shared by the returned imports
+   */
+  List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement);
+
+  /**
+   * Return the element representing the synthetic function `loadLibrary` that is implicitly
+   * defined for this library if the library is imported using a deferred import.
+   */
+  FunctionElement get loadLibraryFunction;
+
+  /**
    * Return an array containing all of the compilation units that are included in this library using
    * a `part` directive. This does not include the defining compilation unit that contains the
    * `part` directives.
    *
    * @return the compilation units that are included in this library
    */
   List<CompilationUnitElement> get parts;
 
   /**
    * Return an array containing elements for each of the prefixes used to `import` libraries
@@ skipping 42 matching lines @@
 
   /**
    * 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.
    *
    * @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 442 matching lines @@
    * declared with the 'const' modifier will return `false` even though they are implicitly
    * 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.
+ * <code>Component</code> annotation.
  */
 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.
+ * <code>Controller</code> annotation.
  */
 abstract class AngularControllerElement implements AngularHasSelectorElement {
 }
 
 /**
  * The interface `AngularDirectiveElement` defines the Angular controller described by
- * <code>NgDirective</code> annotation.
+ * <code>Decorator</code> annotation.
  */
-abstract class AngularDirectiveElement implements AngularHasSelectorElement {
+abstract class AngularDecoratorElement 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);
 }
@@ skipping 10 matching lines @@
 
   /**
    * 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.
+ * The interface `AngularFormatterElement` defines the Angular formatter described by
+ * <code>Formatter</code> annotation.
  */
-abstract class AngularFilterElement implements AngularElement {
+abstract class AngularFormatterElement implements AngularElement {
 }
 
 /**
  * [AngularSelectorElement] based on presence of attribute.
  */
 abstract class AngularHasAttributeSelectorElement implements AngularSelectorElement {
 }
 
 /**
  * [AngularSelectorElement] based on presence of a class.
@@ skipping 317 matching lines @@
  * to not be visited.
  */
 class GeneralizingElementVisitor<R> implements ElementVisitor<R> {
   @override
   R visitAngularComponentElement(AngularComponentElement element) => visitAngularHasSelectorElement(element);
 
   @override
   R visitAngularControllerElement(AngularControllerElement element) => visitAngularHasSelectorElement(element);
 
   @override
-  R visitAngularDirectiveElement(AngularDirectiveElement element) => visitAngularHasSelectorElement(element);
+  R visitAngularDirectiveElement(AngularDecoratorElement element) => visitAngularHasSelectorElement(element);
 
   R visitAngularElement(AngularElement element) => visitToolkitObjectElement(element);
 
   @override
-  R visitAngularFilterElement(AngularFilterElement element) => visitAngularElement(element);
+  R visitAngularFormatterElement(AngularFormatterElement element) => visitAngularElement(element);
 
   R visitAngularHasSelectorElement(AngularHasSelectorElement element) => visitAngularElement(element);
 
   @override
   R visitAngularPropertyElement(AngularPropertyElement element) => visitAngularElement(element);
 
   @override
   R visitAngularScopePropertyElement(AngularScopePropertyElement element) => visitAngularElement(element);
 
   @override
@@ skipping 123 matching lines @@
     return null;
   }
 
   @override
   R visitAngularControllerElement(AngularControllerElement element) {
     element.visitChildren(this);
     return null;
   }
 
   @override
-  R visitAngularDirectiveElement(AngularDirectiveElement element) {
+  R visitAngularDirectiveElement(AngularDecoratorElement element) {
     element.visitChildren(this);
     return null;
   }
 
   @override
-  R visitAngularFilterElement(AngularFilterElement element) {
+  R visitAngularFormatterElement(AngularFormatterElement element) {
     element.visitChildren(this);
     return null;
   }
 
   @override
   R visitAngularPropertyElement(AngularPropertyElement element) {
     element.visitChildren(this);
     return null;
   }
 
@@ skipping 173 matching lines @@
  * whole structure) and that only need to visit a small number of element types.
  */
 class SimpleElementVisitor<R> implements ElementVisitor<R> {
   @override
   R visitAngularComponentElement(AngularComponentElement element) => null;
 
   @override
   R visitAngularControllerElement(AngularControllerElement element) => null;
 
   @override
-  R visitAngularDirectiveElement(AngularDirectiveElement element) => null;
+  R visitAngularDirectiveElement(AngularDecoratorElement element) => null;
 
   @override
-  R visitAngularFilterElement(AngularFilterElement element) => null;
+  R visitAngularFormatterElement(AngularFormatterElement element) => null;
 
   @override
   R visitAngularPropertyElement(AngularPropertyElement element) => null;
 
   @override
   R visitAngularScopePropertyElement(AngularScopePropertyElement element) => null;
 
   @override
   R visitAngularSelectorElement(AngularSelectorElement element) => null;
 
@@ skipping 1016 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.con1(Identifier name) : super.con1(name);
+  ConstructorElementImpl.forNode(Identifier name) : super.forNode(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);
+  ConstructorElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
@@ skipping 872 matching lines @@
   /**
    * An empty array of executable elements.
    */
   static List<ExecutableElement> EMPTY_ARRAY = new List<ExecutableElement>(0);
 
   /**
    * Initialize a newly created executable element to have the given name.
    *
    * @param name the name of this element
    */
-  ExecutableElementImpl.con1(Identifier name) : super.forNode(name);
+  ExecutableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created executable 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
    */
-  ExecutableElementImpl.con2(String name, int nameOffset) : super(name, nameOffset);
+  ExecutableElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   @override
   ElementImpl getChild(String identifier) {
     for (ExecutableElement function in _functions) {
       if ((function as ExecutableElementImpl).identifier == identifier) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
       if ((label as LabelElementImpl).identifier == identifier) {
@@ skipping 275 matching lines @@
   /**
    * An empty array of function elements.
    */
   static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>(0);
 
   /**
    * Initialize a newly created function element to have the given name.
    *
    * @param name the name of this element
    */
-  FunctionElementImpl.con1(Identifier name) : super.con1(name);
+  FunctionElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created function element to have no name and the given offset. This is used
    * for function expressions, which have no name.
    *
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
-  FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset);
+  FunctionElementImpl.forOffset(int nameOffset) : super("", nameOffset);
+
+  /**
+   * Initialize a newly created function element to have the given name and offset.
+   *
+   * @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
+   */
+  FunctionElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   FunctionDeclaration get node => getNodeMatching((node) => node is FunctionDeclaration);
 
@@ skipping 548 matching lines @@
    * `part` directive.
    */
   List<CompilationUnitElement> _parts = CompilationUnitElementImpl.EMPTY_ARRAY;
 
   /**
    * Is `true` if this library is created for Angular analysis.
    */
   bool _isAngularHtml = false;
 
   /**
+   * The element representing the synthetic function `loadLibrary` that is defined for this
+   * library, or `null` if the element has not yet been created.
+   */
+  FunctionElement _loadLibraryFunction;
+
+  /**
    * Initialize a newly created library element to have the given name.
    *
    * @param context the analysis context in which the library is defined
    * @param name the name of this element
    */
   LibraryElementImpl(this.context, LibraryIdentifier name) : super.forNode(name);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 
@@ skipping 50 matching lines @@
         libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
   @override
   List<ImportElement> get imports => _imports;
 
   @override
+  List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) {
+    int count = _imports.length;
+    List<ImportElement> importList = new List<ImportElement>();
+    for (int i = 0; i < count; i++) {
+      if (identical(_imports[i].prefix, prefixElement)) {
+        importList.add(_imports[i]);
+      }
+    }
+    return new List.from(importList);
+  }
+
+  @override
   ElementKind get kind => ElementKind.LIBRARY;
 
   @override
   LibraryElement get library => this;
 
   @override
+  FunctionElement get loadLibraryFunction {
+    if (_loadLibraryFunction == null) {
+      FunctionElementImpl function = new FunctionElementImpl(FunctionElement.LOAD_LIBRARY_NAME, -1);
+      function.synthetic = true;
+      function.enclosingElement = this;
+      function.returnType = loadLibraryReturnType;
+      function.type = new FunctionTypeImpl.con1(function);
+      _loadLibraryFunction = function;
+    }
+    return _loadLibraryFunction;
+  }
+
+  @override
   List<CompilationUnitElement> get parts => _parts;
 
   @override
   List<PrefixElement> get prefixes {
     Set<PrefixElement> prefixes = new Set<PrefixElement>();
     for (ImportElement element in _imports) {
       PrefixElement prefix = element.prefix;
       if (prefix != null) {
         prefixes.add(prefix);
       }
@@ skipping 175 matching lines @@
       for (ExportElement exportElement in _exports) {
         LibraryElement exportedLibrary = exportElement.exportedLibrary;
         if (exportedLibrary != null) {
           (exportedLibrary as LibraryElementImpl)._addVisibleLibraries(visibleLibraries, true);
         }
       }
     }
   }
 
   /**
+   * Return the object representing the type "Future" from the dart:async library, or the type
+   * "void" if the type "Future" cannot be accessed.
+   *
+   * @return the type "Future" from the dart:async library
+   */
+  DartType get loadLibraryReturnType {
+    try {
+      Source asyncSource = context.sourceFactory.forUri(DartSdk.DART_ASYNC);
+      if (asyncSource == null) {
+        AnalysisEngine.instance.logger.logError("Could not create a source for dart:async");
+        return VoidTypeImpl.instance;
+      }
+      LibraryElement asyncElement = context.computeLibraryElement(asyncSource);
+      if (asyncElement == null) {
+        AnalysisEngine.instance.logger.logError("Could not build the element model for dart:async");
+        return VoidTypeImpl.instance;
+      }
+      ClassElement futureElement = asyncElement.getType("Future");
+      if (futureElement == null) {
+        AnalysisEngine.instance.logger.logError("Could not find type Future in dart:async");
+        return VoidTypeImpl.instance;
+      }
+      InterfaceType futureType = futureElement.type;
+      return futureType.substitute4(<DartType> [DynamicTypeImpl.instance]);
+    } on AnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logError2("Could not build the element model for dart:async", exception);
+      return VoidTypeImpl.instance;
+    }
+  }
+
+  /**
    * Answer `true` if the receiver directly or indirectly imports the dart:html libraries.
    *
    * @return `true` if the receiver directly or indirectly imports the dart:html libraries
    */
   bool get isOrImportsBrowserLibrary {
     List<LibraryElement> visited = new List<LibraryElement>();
     Source htmlLibSource = context.sourceFactory.forUri(DartSdk.DART_HTML);
     visited.add(this);
     for (int index = 0; index < visited.length; index++) {
       LibraryElement library = visited[index];
@@ skipping 44 matching lines @@
   /**
    * An empty array of field elements.
    */
   static List<LocalVariableElement> EMPTY_ARRAY = new List<LocalVariableElement>(0);
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
-  LocalVariableElementImpl(Identifier name) : super.con1(name);
+  LocalVariableElementImpl(Identifier name) : super.forNode(name);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
 
   @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
   List<ToolkitObjectElement> get toolkitObjects {
     CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
@@ skipping 75 matching lines @@
   /**
    * 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.
    *
    * @param name the name of this element
    */
-  MethodElementImpl.con1(Identifier name) : super.con1(name);
+  MethodElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created method 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
    */
-  MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
+  MethodElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
   @override
   String get displayName {
     String displayName = super.displayName;
     if ("unary-" == displayName) {
       return "-";
     }
@@ skipping 326 matching lines @@
  * 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.
  */
 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) {
+  MultiplyInheritedMethodElementImpl(Identifier name) : super.forNode(name) {
     synthetic = true;
   }
 
   @override
   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.
  */
 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) {
+  MultiplyInheritedPropertyAccessorElementImpl(Identifier name) : super.forNode(name) {
     synthetic = true;
   }
 
   @override
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
@@ skipping 48 matching lines @@
   /**
    * An empty array of field elements.
    */
   static List<ParameterElement> EMPTY_ARRAY = new List<ParameterElement>(0);
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
-  ParameterElementImpl.con1(Identifier name) : super.con1(name);
+  ParameterElementImpl.con1(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created parameter 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
    */
-  ParameterElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
+  ParameterElementImpl.con2(String name, int nameOffset) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
   @override
   SourceRange get defaultValueRange {
     if (_defaultValueRangeLength < 0) {
       return null;
     }
     return new SourceRange(_defaultValueRangeOffset, _defaultValueRangeLength);
@@ skipping 180 matching lines @@
   /**
    * An empty array of property accessor elements.
    */
   static List<PropertyAccessorElement> EMPTY_ARRAY = new List<PropertyAccessorElement>(0);
 
   /**
    * Initialize a newly created property accessor element to have the given name.
    *
    * @param name the name of this element
    */
-  PropertyAccessorElementImpl.con1(Identifier name) : super.con1(name);
+  PropertyAccessorElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic property accessor element to be associated with the given
    * variable.
    *
    * @param variable the variable with which this access is associated
    */
-  PropertyAccessorElementImpl.con2(PropertyInducingElementImpl variable) : super.con2(variable.name, variable.nameOffset) {
+  PropertyAccessorElementImpl(PropertyInducingElementImpl variable) : super(variable.name, variable.nameOffset) {
     this.variable = variable;
     synthetic = true;
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
   @override
   bool operator ==(Object object) => super == object && isGetter == (object as PropertyAccessorElement).isGetter;
 
@@ skipping 121 matching lines @@
   /**
    * An empty array of elements.
    */
   static List<PropertyInducingElement> EMPTY_ARRAY = new List<PropertyInducingElement>(0);
 
   /**
    * Initialize a newly created element to have the given name.
    *
    * @param name the name of this element
    */
-  PropertyInducingElementImpl.con1(Identifier name) : super.con1(name);
+  PropertyInducingElementImpl.con1(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic element to have the given name.
    *
    * @param name the name of this element
    */
-  PropertyInducingElementImpl.con2(String name) : super.con2(name, -1) {
+  PropertyInducingElementImpl.con2(String name) : super(name, -1) {
     synthetic = true;
   }
 }
 
 /**
  * Instances of the class `ShowElementCombinatorImpl` implement a
  * [ShowElementCombinator].
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
   /**
@@ skipping 166 matching lines @@
   /**
    * An empty array of variable elements.
    */
   static List<VariableElement> EMPTY_ARRAY = new List<VariableElement>(0);
 
   /**
    * Initialize a newly created variable element to have the given name.
    *
    * @param name the name of this element
    */
-  VariableElementImpl.con1(Identifier name) : super.forNode(name);
+  VariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * 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(name, nameOffset);
+  VariableElementImpl(String name, int nameOffset) : super(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, 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;
 
@@ skipping 99 matching lines @@
    * Checks if this application depends on the library with the given [Source].
    */
   bool dependsOn(Source librarySource) => _librarySources.contains(librarySource);
 }
 
 /**
  * Implementation of `AngularComponentElement`.
  */
 class AngularComponentElementImpl extends AngularHasSelectorElementImpl implements AngularComponentElement {
   /**
-   * The offset of the defining <code>NgComponent</code> annotation.
+   * The offset of the defining <code>Component</code> annotation.
    */
   final int _annotationOffset;
 
   /**
    * 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.
@@ skipping 97 matching lines @@
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularControllerElement(this);
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_CONTROLLER;
 }
 
 /**
  * Implementation of `AngularDirectiveElement`.
  */
-class AngularDirectiveElementImpl extends AngularHasSelectorElementImpl implements AngularDirectiveElement {
+class AngularDecoratorElementImpl extends AngularHasSelectorElementImpl implements AngularDecoratorElement {
   /**
    * The offset of the annotation that defines this directive.
    */
   final int _offset;
 
   /**
    * The array containing all of the properties declared by this directive.
    */
   List<AngularPropertyElement> _properties = AngularPropertyElement.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created Angular directive to have the given name.
    *
    * @param offset the offset of the annotation that defines this directive
    */
-  AngularDirectiveElementImpl(this._offset) : super(null, -1);
+  AngularDecoratorElementImpl(this._offset) : super(null, -1);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularDirectiveElement(this);
 
   @override
   String get displayName => selector.displayName;
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_DIRECTIVE;
 
@@ skipping 18 matching lines @@
     this._properties = properties;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChildren(_properties, visitor);
     super.visitChildren(visitor);
   }
 
   @override
-  String get identifier => "NgDirective@${_offset}";
+  String get identifier => "Decorator@${_offset}";
 }
 
 /**
  * Implementation of `AngularElement`.
  */
 abstract class AngularElementImpl extends ToolkitObjectElementImpl implements AngularElement {
   /**
    * The [AngularApplication] this element is used in.
    */
   AngularApplication _application;
@@ skipping 12 matching lines @@
 
   /**
    * Set the [AngularApplication] this element is used in.
    */
   void set application(AngularApplication application) {
     this._application = application;
   }
 }
 
 /**
- * Implementation of `AngularFilterElement`.
+ * Implementation of `AngularFormatterElement`.
  */
-class AngularFilterElementImpl extends AngularElementImpl implements AngularFilterElement {
+class AngularFormatterElementImpl extends AngularElementImpl implements AngularFormatterElement {
   /**
-   * Initialize a newly created Angular filter to have the given name.
+   * Initialize a newly created Angular formatter 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);
+  AngularFormatterElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   @override
-  accept(ElementVisitor visitor) => visitor.visitAngularFilterElement(this);
+  accept(ElementVisitor visitor) => visitor.visitAngularFormatterElement(this);
 
   @override
-  ElementKind get kind => ElementKind.ANGULAR_FILTER;
+  ElementKind get kind => ElementKind.ANGULAR_FORMATTER;
 }
 
 /**
  * Implementation of [AngularSelectorElement] based on presence of a class.
  */
 class AngularHasClassSelectorElementImpl extends AngularSelectorElementImpl implements AngularHasClassSelectorElement {
   AngularHasClassSelectorElementImpl(String name, int offset) : super(name, offset);
 
   @override
   bool apply(XmlTagNode node) {
@@ skipping 108 matching lines @@
   AngularScopePropertyElementImpl(String name, int nameOffset, this.type) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularScopePropertyElement(this);
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_SCOPE_PROPERTY;
 }
 
 /**
- * Implementation of `AngularFilterElement`.
+ * Implementation of `AngularFormatterElement`.
  */
 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 3384 matching lines @@
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
   @override
   VoidType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }