Fix for translation of \!= to \!identical(), but use == and \!= for Enum.

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 713 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 final ElementKind ANGULAR_FILTER = new ElementKind('ANGULAR_FILTER', 0, "Angular filter");
+  static const ElementKind ANGULAR_FILTER = const ElementKind('ANGULAR_FILTER', 0, "Angular filter");
 
-  static final ElementKind ANGULAR_COMPONENT = new ElementKind('ANGULAR_COMPONENT', 1, "Angular component");
+  static const ElementKind ANGULAR_COMPONENT = const ElementKind('ANGULAR_COMPONENT', 1, "Angular component");
 
-  static final ElementKind ANGULAR_CONTROLLER = new ElementKind('ANGULAR_CONTROLLER', 2, "Angular controller");
+  static const ElementKind ANGULAR_CONTROLLER = const ElementKind('ANGULAR_CONTROLLER', 2, "Angular controller");
 
-  static final ElementKind ANGULAR_DIRECTIVE = new ElementKind('ANGULAR_DIRECTIVE', 3, "Angular directive");
+  static const ElementKind ANGULAR_DIRECTIVE = const ElementKind('ANGULAR_DIRECTIVE', 3, "Angular directive");
 
-  static final ElementKind ANGULAR_PROPERTY = new ElementKind('ANGULAR_PROPERTY', 4, "Angular property");
+  static const ElementKind ANGULAR_PROPERTY = const ElementKind('ANGULAR_PROPERTY', 4, "Angular property");
 
-  static final ElementKind ANGULAR_SCOPE_PROPERTY = new ElementKind('ANGULAR_SCOPE_PROPERTY', 5, "Angular scope property");
+  static const ElementKind ANGULAR_SCOPE_PROPERTY = const ElementKind('ANGULAR_SCOPE_PROPERTY', 5, "Angular scope property");
 
-  static final ElementKind ANGULAR_SELECTOR = new ElementKind('ANGULAR_SELECTOR', 6, "Angular selector");
+  static const ElementKind ANGULAR_SELECTOR = const ElementKind('ANGULAR_SELECTOR', 6, "Angular selector");
 
-  static final ElementKind ANGULAR_VIEW = new ElementKind('ANGULAR_VIEW', 7, "Angular view");
+  static const ElementKind ANGULAR_VIEW = const ElementKind('ANGULAR_VIEW', 7, "Angular view");
 
-  static final ElementKind CLASS = new ElementKind('CLASS', 8, "class");
+  static const ElementKind CLASS = const ElementKind('CLASS', 8, "class");
 
-  static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 9, "compilation unit");
+  static const ElementKind COMPILATION_UNIT = const ElementKind('COMPILATION_UNIT', 9, "compilation unit");
 
-  static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 10, "constructor");
+  static const ElementKind CONSTRUCTOR = const ElementKind('CONSTRUCTOR', 10, "constructor");
 
-  static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 11, "<dynamic>");
+  static const ElementKind DYNAMIC = const ElementKind('DYNAMIC', 11, "<dynamic>");
 
-  static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 12, "embedded html script");
+  static const ElementKind EMBEDDED_HTML_SCRIPT = const ElementKind('EMBEDDED_HTML_SCRIPT', 12, "embedded html script");
 
-  static final ElementKind ERROR = new ElementKind('ERROR', 13, "<error>");
+  static const ElementKind ERROR = const ElementKind('ERROR', 13, "<error>");
 
-  static final ElementKind EXPORT = new ElementKind('EXPORT', 14, "export directive");
+  static const ElementKind EXPORT = const ElementKind('EXPORT', 14, "export directive");
 
-  static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 15, "external html script");
+  static const ElementKind EXTERNAL_HTML_SCRIPT = const ElementKind('EXTERNAL_HTML_SCRIPT', 15, "external html script");
 
-  static final ElementKind FIELD = new ElementKind('FIELD', 16, "field");
+  static const ElementKind FIELD = const ElementKind('FIELD', 16, "field");
 
-  static final ElementKind FUNCTION = new ElementKind('FUNCTION', 17, "function");
+  static const ElementKind FUNCTION = const ElementKind('FUNCTION', 17, "function");
 
-  static final ElementKind GETTER = new ElementKind('GETTER', 18, "getter");
+  static const ElementKind GETTER = const ElementKind('GETTER', 18, "getter");
 
-  static final ElementKind HTML = new ElementKind('HTML', 19, "html");
+  static const ElementKind HTML = const ElementKind('HTML', 19, "html");
 
-  static final ElementKind IMPORT = new ElementKind('IMPORT', 20, "import directive");
+  static const ElementKind IMPORT = const ElementKind('IMPORT', 20, "import directive");
 
-  static final ElementKind LABEL = new ElementKind('LABEL', 21, "label");
+  static const ElementKind LABEL = const ElementKind('LABEL', 21, "label");
 
-  static final ElementKind LIBRARY = new ElementKind('LIBRARY', 22, "library");
+  static const ElementKind LIBRARY = const ElementKind('LIBRARY', 22, "library");
 
-  static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 23, "local variable");
+  static const ElementKind LOCAL_VARIABLE = const ElementKind('LOCAL_VARIABLE', 23, "local variable");
 
-  static final ElementKind METHOD = new ElementKind('METHOD', 24, "method");
+  static const ElementKind METHOD = const ElementKind('METHOD', 24, "method");
 
-  static final ElementKind NAME = new ElementKind('NAME', 25, "<name>");
+  static const ElementKind NAME = const ElementKind('NAME', 25, "<name>");
 
-  static final ElementKind PARAMETER = new ElementKind('PARAMETER', 26, "parameter");
+  static const ElementKind PARAMETER = const ElementKind('PARAMETER', 26, "parameter");
 
-  static final ElementKind PREFIX = new ElementKind('PREFIX', 27, "import prefix");
+  static const ElementKind PREFIX = const ElementKind('PREFIX', 27, "import prefix");
 
-  static final ElementKind SETTER = new ElementKind('SETTER', 28, "setter");
+  static const ElementKind SETTER = const ElementKind('SETTER', 28, "setter");
 
-  static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 29, "top level variable");
+  static const ElementKind TOP_LEVEL_VARIABLE = const ElementKind('TOP_LEVEL_VARIABLE', 29, "top level variable");
 
-  static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 30, "function type alias");
+  static const ElementKind FUNCTION_TYPE_ALIAS = const ElementKind('FUNCTION_TYPE_ALIAS', 30, "function type alias");
 
-  static final ElementKind TYPE_PARAMETER = new ElementKind('TYPE_PARAMETER', 31, "type parameter");
+  static const ElementKind TYPE_PARAMETER = const ElementKind('TYPE_PARAMETER', 31, "type parameter");
 
-  static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 32, "<universe>");
+  static const ElementKind UNIVERSE = const ElementKind('UNIVERSE', 32, "<universe>");
 
-  static final List<ElementKind> values = [
+  static const List<ElementKind> values = const [
       ANGULAR_FILTER,
       ANGULAR_COMPONENT,
       ANGULAR_CONTROLLER,
       ANGULAR_DIRECTIVE,
       ANGULAR_PROPERTY,
       ANGULAR_SCOPE_PROPERTY,
       ANGULAR_SELECTOR,
       ANGULAR_VIEW,
       CLASS,
       COMPILATION_UNIT,
@@ skipping 31 matching lines @@
   static ElementKind of(Element element) {
     if (element == null) {
       return ERROR;
     }
     return element.kind;
   }
 
   /**
    * The name displayed in the UI for this kind of element.
    */
-  String displayName;
+  final String displayName;
 
   /**
    * Initialize a newly created element kind to have the given display name.
    *
    * @param displayName the name displayed in the UI for this kind of element
    */
-  ElementKind(String name, int ordinal, String displayName) : super(name, ordinal) {
-    this.displayName = displayName;
-  }
+  const ElementKind(String name, int ordinal, this.displayName) : super(name, ordinal);
 }
 
 /**
  * The interface `ElementLocation` defines the behavior of objects that represent the location
  * of an element within the element model.
  */
 abstract class ElementLocation {
   /**
    * Return an encoded representation of this location that can be used to create a location that is
    * equal to this location.
@@ skipping 1108 matching lines @@
 
 /**
  * The enumeration `AngularPropertyKind` defines the different kinds of property bindings.
  */
 class AngularPropertyKind extends Enum<AngularPropertyKind> {
   /**
    * `@` - Map the DOM attribute string. The attribute string will be taken literally or
    * interpolated if it contains binding {{}} syntax and assigned to the expression. (cost: 0
    * watches)
    */
-  static final AngularPropertyKind ATTR = new AngularPropertyKind('ATTR', 0);
+  static const AngularPropertyKind ATTR = const AngularPropertyKind('ATTR', 0);
 
   /**
    * `&` - Treat the DOM attribute value as an expression. Assign a closure function into the field.
    * This allows the component to control the invocation of the closure. This is useful for passing
    * expressions into controllers which act like callbacks. (cost: 0 watches)
    */
-  static final AngularPropertyKind CALLBACK = new AngularPropertyKind('CALLBACK', 1);
+  static const AngularPropertyKind CALLBACK = const AngularPropertyKind('CALLBACK', 1);
 
   /**
    * `=>` - Treat the DOM attribute value as an expression. Set up a watch, which will read the
    * expression in the attribute and assign the value to destination expression. (cost: 1 watch)
    */
-  static final AngularPropertyKind ONE_WAY = new AngularPropertyKind('ONE_WAY', 2);
+  static const AngularPropertyKind ONE_WAY = const AngularPropertyKind('ONE_WAY', 2);
 
   /**
    * `=>!` - Treat the DOM attribute value as an expression. Set up a one time watch on expression.
    * Once the expression turns not null it will no longer update. (cost: 1 watches until not null,
    * then 0 watches)
    */
-  static final AngularPropertyKind ONE_WAY_ONE_TIME = new AngularPropertyKind('ONE_WAY_ONE_TIME', 3);
+  static const AngularPropertyKind ONE_WAY_ONE_TIME = const AngularPropertyKind('ONE_WAY_ONE_TIME', 3);
 
   /**
    * `<=>` - Treat the DOM attribute value as an expression. Set up a watch on both outside as well
    * as component scope to keep the source and destination in sync. (cost: 2 watches)
    */
-  static final AngularPropertyKind TWO_WAY = new AngularPropertyKind_TWO_WAY('TWO_WAY', 4);
+  static const AngularPropertyKind TWO_WAY = const AngularPropertyKind_TWO_WAY('TWO_WAY', 4);
 
-  static final List<AngularPropertyKind> values = [ATTR, CALLBACK, ONE_WAY, ONE_WAY_ONE_TIME, TWO_WAY];
+  static const List<AngularPropertyKind> values = const [ATTR, CALLBACK, ONE_WAY, ONE_WAY_ONE_TIME, TWO_WAY];
 
   /**
    * Returns `true` if property of this kind calls field getter.
    */
   bool callsGetter() => false;
 
   /**
    * Returns `true` if property of this kind calls field setter.
    */
   bool callsSetter() => true;
 
-  AngularPropertyKind(String name, int ordinal) : super(name, ordinal);
+  const AngularPropertyKind(String name, int ordinal) : super(name, ordinal);
 }
 
 class AngularPropertyKind_TWO_WAY extends AngularPropertyKind {
-  AngularPropertyKind_TWO_WAY(String name, int ordinal) : super(name, ordinal);
+  const AngularPropertyKind_TWO_WAY(String name, int ordinal) : super(name, ordinal);
 
   @override
   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.
  */
 abstract class AngularScopePropertyElement implements AngularElement {
@@ skipping 515 matching lines @@
  * [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
  * [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
  * using propagated type information, this class is a wrapper for a pair of
  * [ExecutableElement]s, not just a single [ExecutableElement].
  */
 class AuxiliaryElements {
   /**
    * The element based on propagated type information, or `null` if the AST structure has not
    * been resolved or if this identifier could not be resolved.
    */
-  ExecutableElement propagatedElement;
+  final ExecutableElement propagatedElement;
 
   /**
    * The element associated with this identifier based on static type information, or `null`
    * if the AST structure has not been resolved or if this identifier could not be resolved.
    */
-  ExecutableElement staticElement;
+  final ExecutableElement staticElement;
 
   /**
    * Create the [AuxiliaryElements] with a static and propagated [ExecutableElement].
    *
    * @param staticElement the static element
    * @param propagatedElement the propagated element
    */
-  AuxiliaryElements(ExecutableElement staticElement, ExecutableElement propagatedElement) {
-    this.staticElement = staticElement;
-    this.propagatedElement = propagatedElement;
-  }
+  AuxiliaryElements(this.staticElement, this.propagatedElement);
 }
 
 /**
  * Instances of the class `ClassElementImpl` implement a `ClassElement`.
  */
 class ClassElementImpl extends ElementImpl implements ClassElement {
   /**
    * An array containing all of the accessors (getters and setters) contained in this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
@@ skipping 490 matching lines @@
 
   void _collectAllSupertypes(List<InterfaceType> supertypes) {
     List<InterfaceType> typesToVisit = new List<InterfaceType>();
     List<ClassElement> visitedClasses = new List<ClassElement>();
     typesToVisit.add(this.type);
     while (!typesToVisit.isEmpty) {
       InterfaceType currentType = typesToVisit.removeAt(0);
       ClassElement currentElement = currentType.element;
       if (!visitedClasses.contains(currentElement)) {
         visitedClasses.add(currentElement);
-        if (currentType != this.type) {
+        if (!identical(currentType, this.type)) {
           supertypes.add(currentType);
         }
         InterfaceType supertype = currentType.superclass;
         if (supertype != null) {
           typesToVisit.add(supertype);
         }
         for (InterfaceType type in currentElement.interfaces) {
           typesToVisit.add(type);
         }
         for (InterfaceType type in currentElement.mixins) {
@@ skipping 416 matching lines @@
 
   @override
   bool get isDefaultConstructor {
     // unnamed
     String name = this.name;
     if (name != null && name.length != 0) {
       return false;
     }
     // no required parameters
     for (ParameterElement parameter in parameters) {
-      if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
+      if (parameter.parameterKind == ParameterKind.REQUIRED) {
         return false;
       }
     }
     // OK, can be used as default constructor
     return true;
   }
 
   @override
   bool get isFactory => hasModifier(Modifier.FACTORY);
 
@@ skipping 115 matching lines @@
   ElementKind get kind => ElementKind.DYNAMIC;
 }
 
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
-  Element element;
+  final Element element;
 
   /**
    * An empty array of annotations.
    */
   static List<ElementAnnotationImpl> EMPTY_ARRAY = new List<ElementAnnotationImpl>(0);
 
   /**
    * The name of the class used to mark an element as being deprecated.
    */
   static String _DEPRECATED_CLASS_NAME = "Deprecated";
@@ skipping 13 matching lines @@
    * The name of the top-level variable used to mark a class as implementing a proxy object.
    */
   static String _PROXY_VARIABLE_NAME = "proxy";
 
   /**
    * Initialize a newly created annotation.
    *
    * @param element the element representing the field, variable, or constructor being used as an
    *          annotation
    */
-  ElementAnnotationImpl(Element element) {
-    this.element = element;
-  }
+  ElementAnnotationImpl(this.element);
 
   @override
   bool get isDeprecated {
     if (element != null) {
       LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
         if (element is ConstructorElement) {
           ConstructorElement constructorElement = element as ConstructorElement;
           if (constructorElement.enclosingElement.name == _DEPRECATED_CLASS_NAME) {
             return true;
@@ skipping 80 matching lines @@
    */
   ElementImpl.forNode(Identifier name) : this(name == null ? "" : name.name, name == null ? -1 : name.offset);
 
   /**
    * Initialize a newly created 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
    */
-  ElementImpl(String name, int nameOffset) {
+  ElementImpl(String name, this.nameOffset) {
     this._name = StringUtilities.intern(name);
-    this.nameOffset = nameOffset;
   }
 
   @override
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
@@ skipping 442 matching lines @@
 }
 
 /**
  * The class `ElementPair` is a pair of [Element]s. [Object#equals] and
  * [Object#hashCode] so this class can be used in hashed data structures.
  */
 class ElementPair {
   /**
    * The first [Element]
    */
-  Element _first;
+  final Element _first;
 
   /**
    * The second [Element]
    */
-  Element _second;
+  final Element _second;
 
   /**
    * The sole constructor for this class, taking two [Element]s.
    *
    * @param first the first element
    * @param second the second element
    */
-  ElementPair(Element first, Element second) {
-    this._first = first;
-    this._second = second;
-  }
+  ElementPair(this._first, this._second);
 
   @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object is ElementPair) {
       ElementPair elementPair = object;
       return (_first == elementPair._first) && (_second == elementPair._second);
     }
@@ skipping 223 matching lines @@
       for (int i = 0; i < parameterCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         ParameterElementImpl parameter = _parameters[i] as ParameterElementImpl;
         ParameterKind parameterKind = parameter.parameterKind;
         if (parameterKind != kind) {
           if (closing != null) {
             builder.append(closing);
           }
-          if (identical(parameterKind, ParameterKind.POSITIONAL)) {
+          if (parameterKind == ParameterKind.POSITIONAL) {
             builder.append("[");
             closing = "]";
-          } else if (identical(parameterKind, ParameterKind.NAMED)) {
+          } else if (parameterKind == ParameterKind.NAMED) {
             builder.append("{");
             closing = "}";
           } else {
             closing = null;
           }
         }
         kind = parameterKind;
         parameter.appendToWithoutDelimiters(builder);
       }
       if (closing != null) {
@@ skipping 407 matching lines @@
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty array of HTML file elements.
    */
   static List<HtmlElement> EMPTY_ARRAY = new List<HtmlElement>(0);
 
   /**
    * The analysis context in which this library is defined.
    */
-  AnalysisContext context;
+  final AnalysisContext context;
 
   /**
    * The scripts contained in or referenced from script tags in the HTML file.
    */
   List<HtmlScriptElement> _scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
 
   /**
    * The source that corresponds to this HTML file.
    */
   Source source;
 
   /**
    * The element associated with Dart pieces in this HTML unit or `null` if the receiver is
    * not resolved.
    */
   CompilationUnitElement angularCompilationUnit;
 
   /**
    * 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(AnalysisContext context, String name) : super(name, -1) {
-    this.context = context;
-  }
+  HtmlElementImpl(this.context, String name) : super(name, -1);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitHtmlElement(this);
 
   @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object == null) {
@@ skipping 115 matching lines @@
   String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${nameOffset}";
 }
 
 /**
  * Instances of the class `LabelElementImpl` implement a `LabelElement`.
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch` statement.
    */
-  bool _onSwitchStatement = false;
+  final bool _onSwitchStatement;
 
   /**
    * A flag indicating whether this label is associated with a `switch` member (`case`
    * or `default`).
    */
-  bool _onSwitchMember = false;
+  final bool _onSwitchMember;
 
   /**
    * An empty array of label elements.
    */
   static List<LabelElement> EMPTY_ARRAY = new List<LabelElement>(0);
 
   /**
    * Initialize a newly created label element to have the given name.
    *
    * @param name the name of this element
    * @param onSwitchStatement `true` if this label is associated with a `switch`
    *          statement
    * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
-  LabelElementImpl(Identifier name, bool onSwitchStatement, bool onSwitchMember) : super.forNode(name) {
-    this._onSwitchStatement = onSwitchStatement;
-    this._onSwitchMember = onSwitchMember;
-  }
+  LabelElementImpl(Identifier name, this._onSwitchStatement, this._onSwitchMember) : super.forNode(name);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
 
   @override
   ExecutableElement get enclosingElement => super.enclosingElement as ExecutableElement;
 
   @override
   ElementKind get kind => ElementKind.LABEL;
 
@@ skipping 55 matching lines @@
           return false;
         }
       }
     }
     return true;
   }
 
   /**
    * The analysis context in which this library is defined.
    */
-  AnalysisContext context;
+  final AnalysisContext context;
 
   /**
    * The compilation unit that defines this library.
    */
   CompilationUnitElement _definingCompilationUnit;
 
   /**
    * The entry point for this library, or `null` if this library does not have an entry point.
    */
   FunctionElement entryPoint;
@@ skipping 18 matching lines @@
    * Is `true` if this library is created for Angular analysis.
    */
   bool _isAngularHtml = false;
 
   /**
    * 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(AnalysisContext context, LibraryIdentifier name) : super.forNode(name) {
-    this.context = context;
-  }
+  LibraryElementImpl(this.context, LibraryIdentifier name) : super.forNode(name);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 
   @override
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _definingCompilationUnit == (object as LibraryElementImpl).definingCompilationUnit;
 
   @override
   ElementImpl getChild(String identifier) {
     if ((_definingCompilationUnit as CompilationUnitElementImpl).identifier == identifier) {
@@ skipping 477 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.
  */
 class Modifier extends Enum<Modifier> {
   /**
    * Indicates that the modifier 'abstract' was applied to the element.
    */
-  static final Modifier ABSTRACT = new Modifier('ABSTRACT', 0);
+  static const Modifier ABSTRACT = const Modifier('ABSTRACT', 0);
 
   /**
    * Indicates that the modifier 'const' was applied to the element.
    */
-  static final Modifier CONST = new Modifier('CONST', 1);
+  static const Modifier CONST = const Modifier('CONST', 1);
 
   /**
    * Indicates that the modifier 'factory' was applied to the element.
    */
-  static final Modifier FACTORY = new Modifier('FACTORY', 2);
+  static const Modifier FACTORY = const Modifier('FACTORY', 2);
 
   /**
    * Indicates that the modifier 'final' was applied to the element.
    */
-  static final Modifier FINAL = new Modifier('FINAL', 3);
+  static const Modifier FINAL = const Modifier('FINAL', 3);
 
   /**
    * Indicates that the pseudo-modifier 'get' was applied to the element.
    */
-  static final Modifier GETTER = new Modifier('GETTER', 4);
+  static const Modifier GETTER = const Modifier('GETTER', 4);
 
   /**
    * 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 const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 5);
 
-  static final Modifier MIXIN = new Modifier('MIXIN', 6);
+  static const Modifier MIXIN = const Modifier('MIXIN', 6);
 
-  static final Modifier REFERENCES_SUPER = new Modifier('REFERENCES_SUPER', 7);
+  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 7);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static final Modifier SETTER = new Modifier('SETTER', 8);
+  static const Modifier SETTER = const Modifier('SETTER', 8);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static final Modifier STATIC = new Modifier('STATIC', 9);
+  static const Modifier STATIC = const Modifier('STATIC', 9);
 
   /**
    * 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 const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 10);
 
-  static final Modifier TYPEDEF = new Modifier('TYPEDEF', 11);
+  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 11);
 
-  static final List<Modifier> values = [
+  static const List<Modifier> values = const [
       ABSTRACT,
       CONST,
       FACTORY,
       FINAL,
       GETTER,
       HAS_EXT_URI,
       MIXIN,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
 
-  Modifier(String name, int ordinal) : super(name, ordinal);
+  const Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * Instances of the class `MultiplyDefinedElementImpl` represent a collection of elements that
  * have the same name within the same scope.
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
   /**
    * Return an element that represents the given conflicting elements.
    *
@@ skipping 41 matching lines @@
   static List<Element> _computeConflictingElements(Element firstElement, Element secondElement) {
     Set<Element> elements = new Set<Element>();
     _add(elements, firstElement);
     _add(elements, secondElement);
     return new List.from(elements);
   }
 
   /**
    * The analysis context in which the multiply defined elements are defined.
    */
-  AnalysisContext context;
+  final AnalysisContext context;
 
   /**
    * The name of the conflicting elements.
    */
   String _name;
 
   /**
    * A list containing all of the elements that conflict.
    */
-  List<Element> conflictingElements;
+  final List<Element> conflictingElements;
 
   /**
    * Initialize a newly created element to represent a list of conflicting elements.
    *
    * @param context the analysis context in which the multiply defined elements are defined
    * @param conflictingElements the elements that conflict
    */
-  MultiplyDefinedElementImpl(AnalysisContext context, List<Element> conflictingElements) {
-    this.context = context;
+  MultiplyDefinedElementImpl(this.context, this.conflictingElements) {
     _name = conflictingElements[0].name;
-    this.conflictingElements = conflictingElements;
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
 
   @override
   String computeDocumentationComment() => null;
 
   @override
   Element getAncestor(Predicate<Element> predicate) => null;
@@ skipping 408 matching lines @@
    */
   PropertyAccessorElementImpl.con2(PropertyInducingElementImpl variable) : super.con2(variable.name, variable.nameOffset) {
     this.variable = variable;
     synthetic = true;
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
   @override
-  bool operator ==(Object object) => super == object && identical(isGetter, (object as PropertyAccessorElement).isGetter);
+  bool operator ==(Object object) => super == object && isGetter == (object as PropertyAccessorElement).isGetter;
 
   @override
   PropertyAccessorElement get correspondingGetter {
     if (isGetter || variable == null) {
       return null;
     }
     return variable.getter;
   }
 
   @override
@@ skipping 414 matching lines @@
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 }
 
 /**
  * Information about Angular application.
  */
 class AngularApplication {
-  Source entryPoint;
+  final Source entryPoint;
 
-  Set<Source> _librarySources;
+  final Set<Source> _librarySources;
 
-  List<AngularElement> elements;
+  final List<AngularElement> elements;
 
-  List<Source> elementSources;
+  final List<Source> elementSources;
 
-  AngularApplication(Source entryPoint, Set<Source> librarySources, List<AngularElement> elements, List<Source> elementSources) {
-    this.entryPoint = entryPoint;
-    this._librarySources = librarySources;
-    this.elements = elements;
-    this.elementSources = elementSources;
-  }
+  AngularApplication(this.entryPoint, this._librarySources, this.elements, this.elementSources);
 
   /**
    * 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.
    */
-  int _annotationOffset = 0;
+  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.
    */
   List<AngularScopePropertyElement> _scopeProperties = AngularScopePropertyElement.EMPTY_ARRAY;
@@ skipping 23 matching lines @@
    */
   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
    */
-  AngularComponentElementImpl(String name, int nameOffset, int annotationOffset) : super(name, nameOffset) {
-    this._annotationOffset = annotationOffset;
-  }
+  AngularComponentElementImpl(String name, int nameOffset, this._annotationOffset) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularComponentElement(this);
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_COMPONENT;
 
   @override
   List<AngularPropertyElement> get properties => _properties;
 
@@ skipping 55 matching lines @@
   ElementKind get kind => ElementKind.ANGULAR_CONTROLLER;
 }
 
 /**
  * Implementation of `AngularDirectiveElement`.
  */
 class AngularDirectiveElementImpl extends AngularHasSelectorElementImpl implements AngularDirectiveElement {
   /**
    * The offset of the annotation that defines this directive.
    */
-  int _offset = 0;
+  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(int offset) : super(null, -1) {
-    this._offset = offset;
-  }
+  AngularDirectiveElementImpl(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 177 matching lines @@
   ElementKind get kind => ElementKind.ANGULAR_PROPERTY;
 }
 
 /**
  * Implementation of `AngularScopePropertyElement`.
  */
 class AngularScopePropertyElementImpl extends AngularElementImpl implements AngularScopePropertyElement {
   /**
    * The type of the property
    */
-  DartType type;
+  final DartType 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, DartType type) : super(name, nameOffset) {
-    this.type = type;
-  }
+  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`.
@@ skipping 31 matching lines @@
   AngularApplication get application => (enclosingElement as AngularElementImpl).application;
 }
 
 /**
  * Implementation of `AngularViewElement`.
  */
 class AngularViewElementImpl extends AngularElementImpl implements AngularViewElement {
   /**
    * The HTML template URI.
    */
-  String templateUri;
+  final String templateUri;
 
   /**
    * The offset of the [templateUri] in the [getSource].
    */
-  int templateUriOffset = 0;
+  final int templateUriOffset;
 
   /**
    * The HTML template source.
    */
   Source templateSource;
 
   /**
    * Initialize a newly created Angular view.
    */
-  AngularViewElementImpl(String templateUri, int templateUriOffset) : super(null, -1) {
-    this.templateUri = templateUri;
-    this.templateUriOffset = templateUriOffset;
-  }
+  AngularViewElementImpl(this.templateUri, this.templateUriOffset) : super(null, -1);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitAngularViewElement(this);
 
   @override
   ElementKind get kind => ElementKind.ANGULAR_VIEW;
 
   @override
   String get identifier => "AngularView@${templateUriOffset}";
 }
@@ skipping 15 matching lines @@
     builder.append("[");
     builder.append(name);
     builder.append("]");
   }
 }
 
 /**
  * Combination of [AngularTagSelectorElementImpl] and [HasAttributeSelectorElementImpl].
  */
 class IsTagHasAttributeSelectorElementImpl extends AngularSelectorElementImpl {
-  String tagName;
+  final String tagName;
 
-  String attributeName;
+  final String attributeName;
 
-  IsTagHasAttributeSelectorElementImpl(String tagName, String attributeName) : super(null, -1) {
-    this.tagName = tagName;
-    this.attributeName = attributeName;
-  }
+  IsTagHasAttributeSelectorElementImpl(this.tagName, this.attributeName) : super(null, -1);
 
   @override
   bool apply(XmlTagNode node) => node.tag == tagName && node.getAttribute(attributeName) != null;
 }
 
 /**
  * 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 {
@@ skipping 253 matching lines @@
 }
 
 /**
  * The abstract class `Member` defines the behavior common to elements that represent members
  * of parameterized types.
  */
 abstract class Member implements Element {
   /**
    * The element on which the parameterized element was created.
    */
-  Element _baseElement;
+  final Element _baseElement;
 
   /**
    * The type in which the element is defined.
    */
-  ParameterizedType _definingType;
+  final ParameterizedType _definingType;
 
   /**
    * Initialize a newly created element to represent the member of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
-  Member(Element baseElement, ParameterizedType definingType) {
-    this._baseElement = baseElement;
-    this._definingType = definingType;
-  }
+  Member(this._baseElement, this._definingType);
 
   @override
   String computeDocumentationComment() => _baseElement.computeDocumentationComment();
 
   @override
   Element getAncestor(Predicate<Element> predicate) => baseElement.getAncestor(predicate);
 
   /**
    * Return the element on which the parameterized element was created.
    *
@@ skipping 724 matching lines @@
 
   @override
   Map<String, DartType> get namedParameterTypes {
     LinkedHashMap<String, DartType> namedParameterTypes = new LinkedHashMap<String, DartType>();
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return namedParameterTypes;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     for (ParameterElement parameter in parameters) {
-      if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
+      if (parameter.parameterKind == ParameterKind.NAMED) {
         namedParameterTypes[parameter.name] = parameter.type.substitute2(typeArguments, typeParameters);
       }
     }
     return namedParameterTypes;
   }
 
   @override
   List<DartType> get normalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
-      if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
+      if (parameter.parameterKind == ParameterKind.REQUIRED) {
         types.add(parameter.type.substitute2(typeArguments, typeParameters));
       }
     }
     return new List.from(types);
   }
 
   @override
   List<DartType> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
-      if (identical(parameter.parameterKind, ParameterKind.POSITIONAL)) {
+      if (parameter.parameterKind == ParameterKind.POSITIONAL) {
         types.add(parameter.type.substitute2(typeArguments, typeParameters));
       }
     }
     return new List.from(types);
   }
 
   @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = this.baseParameters;
     // no parameters, quick return
@@ skipping 1181 matching lines @@
     for (int i = 0; i < length; i++) {
       newTypes[i] = types[i].substitute2(argumentTypes, parameterTypes);
     }
     return newTypes;
   }
 
   /**
    * The element representing the declaration of this type, or `null` if the type has not, or
    * cannot, be associated with an element.
    */
-  Element _element;
+  final Element _element;
 
   /**
    * The name of this type, or `null` if the type does not have a name.
    */
-  String name;
+  final String name;
 
   /**
    * An empty array of types.
    */
   static List<DartType> EMPTY_ARRAY = new List<DartType>(0);
 
   /**
    * Initialize a newly created type to be declared by the given element and to have the given name.
    *
    * @param element the element representing the declaration of the type
    * @param name the name of the type
    */
-  TypeImpl(Element element, String name) {
-    this._element = element;
-    this.name = name;
-  }
+  TypeImpl(this._element, this.name);
 
   @override
   String get displayName => name;
 
   @override
   Element get element => _element;
 
   @override
   DartType getLeastUpperBound(DartType type) => null;
 
@@ skipping 105 matching lines @@
   }
 
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs);
 
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs);
 
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs);
 }
 
 class TypeImpl_TypePair {
-  DartType _firstType;
+  final DartType _firstType;
 
-  DartType _secondType;
+  final DartType _secondType;
 
   int _cachedHashCode = 0;
 
-  TypeImpl_TypePair(DartType firstType, DartType secondType) {
-    this._firstType = firstType;
-    this._secondType = secondType;
-  }
+  TypeImpl_TypePair(this._firstType, this._secondType);
 
   @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object is TypeImpl_TypePair) {
       TypeImpl_TypePair typePair = object;
       return _firstType == typePair._firstType && _secondType != null && _secondType == typePair._secondType;
     }
@@ skipping 762 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);
 }