New analyzer snapshot.

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

 // 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';
@@ skipping 695 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;
-  }
+  ElementKind(String name, int ordinal, this.displayName) : super(name, ordinal);
 }
 
 /**
  * The interface `ElementLocation` defines the behavior of objects that represent the location
  * of an element within the element model.
  *
  * @coverage dart.engine.element
  */
 abstract class ElementLocation {
   /**
@@ skipping 1183 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`.
  *
  * @coverage dart.engine.element
  */
 class ClassElementImpl extends ElementImpl implements ClassElement {
   /**
    * An array containing all of the accessors (getters and setters) contained in this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the constructors contained in this class.
    */
   List<ConstructorElement> _constructors = ConstructorElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the fields contained in this class.
    */
   List<FieldElement> _fields = FieldElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the mixins that are applied to the class being extended in order to
    * derive the superclass of this class.
    */
-  List<InterfaceType> _mixins = InterfaceTypeImpl.EMPTY_ARRAY;
+  List<InterfaceType> mixins = InterfaceTypeImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the interfaces that are implemented by this class.
    */
-  List<InterfaceType> _interfaces = InterfaceTypeImpl.EMPTY_ARRAY;
+  List<InterfaceType> interfaces = InterfaceTypeImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the methods contained in this class.
    */
   List<MethodElement> _methods = MethodElementImpl.EMPTY_ARRAY;
 
   /**
    * The superclass of the class, or `null` if the class does not have an explicit superclass.
    */
-  InterfaceType _supertype;
+  InterfaceType supertype;
 
   /**
    * The type defined by the class.
    */
-  InterfaceType _type;
+  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.
    */
   static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
@@ skipping 66 matching lines @@
 
   PropertyAccessorElement getGetter(String getterName) {
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isGetter && accessor.name == getterName) {
         return accessor;
       }
     }
     return null;
   }
 
-  List<InterfaceType> get interfaces => _interfaces;
-
   ElementKind get kind => ElementKind.CLASS;
 
   MethodElement getMethod(String methodName) {
     for (MethodElement method in _methods) {
       if (method.name == methodName) {
         return method;
       }
     }
     return null;
   }
 
   List<MethodElement> get methods => _methods;
 
-  List<InterfaceType> get mixins => _mixins;
-
   ConstructorElement getNamedConstructor(String name) {
     for (ConstructorElement element in constructors) {
       String elementName = element.name;
       if (elementName != null && elementName == name) {
         return element;
       }
     }
     return null;
   }
 
   PropertyAccessorElement getSetter(String setterName) {
     if (!setterName.endsWith("=")) {
       setterName += '=';
     }
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
 
-  InterfaceType get supertype => _supertype;
-
-  InterfaceType get type => _type;
-
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
       String name = element.displayName;
       if (name == null || name.isEmpty) {
         return element;
       }
     }
     return null;
@@ skipping 173 matching lines @@
   /**
    * Set whether this class references 'super' to the given value.
    *
    * @param isReferencedSuper `true` references 'super'
    */
   void set hasReferenceToSuper2(bool isReferencedSuper) {
     setModifier(Modifier.REFERENCES_SUPER, isReferencedSuper);
   }
 
   /**
-   * Set the interfaces that are implemented by this class to the given types.
-   *
-   * @param the interfaces that are implemented by this class
-   */
-  void set interfaces(List<InterfaceType> interfaces) {
-    this._interfaces = interfaces;
-  }
-
-  /**
    * Set the methods contained in this class to the given methods.
    *
    * @param methods the methods contained in this class
    */
   void set methods(List<MethodElement> methods) {
     for (MethodElement method in methods) {
       (method as MethodElementImpl).enclosingElement = this;
     }
     this._methods = methods;
   }
 
   /**
-   * Set the mixins that are applied to the class being extended in order to derive the superclass
-   * of this class to the given types.
-   *
-   * @param mixins the mixins that are applied to derive the superclass of this class
-   */
-  void set mixins(List<InterfaceType> mixins) {
-    this._mixins = mixins;
-  }
-
-  /**
-   * Set the superclass of the class to the given type.
-   *
-   * @param supertype the superclass of the class
-   */
-  void set supertype(InterfaceType supertype) {
-    this._supertype = supertype;
-  }
-
-  /**
-   * Set the type defined by the class to the given type.
-   *
-   * @param type the type defined by the class
-   */
-  void set type(InterfaceType type) {
-    this._type = type;
-  }
-
-  /**
    * Set whether this class is defined by a typedef construct to correspond to the given value.
    *
    * @param isTypedef `true` if the class is defined by a typedef construct
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
 
   /**
    * Set the type parameters defined for this class to the given type parameters.
@@ skipping 99 matching lines @@
   List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the variables contained in this compilation unit.
    */
   List<TopLevelVariableElement> _variables = TopLevelVariableElementImpl.EMPTY_ARRAY;
 
   /**
    * The source that corresponds to this compilation unit.
    */
-  Source _source;
+  Source source;
 
   /**
    * An array containing all of the function type aliases contained in this compilation unit.
    */
   List<FunctionTypeAliasElement> _typeAliases = FunctionTypeAliasElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the types contained in this compilation unit.
    */
   List<ClassElement> _types = ClassElementImpl.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;
+  String uri;
 
   /**
    * 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;
+  bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && source == (object as CompilationUnitElementImpl).source;
 
   List<PropertyAccessorElement> get accessors => _accessors;
 
   ElementImpl getChild(String identifier) {
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
     for (VariableElement variable in _variables) {
@@ skipping 20 matching lines @@
   }
 
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
 
   List<FunctionElement> get functions => _functions;
 
   List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
 
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
 
-  Source get source => _source;
-
   List<TopLevelVariableElement> get topLevelVariables => _variables;
 
   ClassElement getType(String className) {
     for (ClassElement type in _types) {
       if (type.name == className) {
         return type;
       }
     }
     return null;
   }
 
   List<ClassElement> get types => _types;
 
-  String get uri => _uri;
-
-  int get hashCode => _source.hashCode;
+  int get hashCode => source.hashCode;
 
   /**
    * Set the top-level accessors (getters and setters) contained in this compilation unit to the
    * given accessors.
    *
    * @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 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;
   }
 
   /**
-   * Set the source that corresponds to this compilation unit to the given source.
-   *
-   * @param source the source that corresponds to this compilation unit
-   */
-  void set source(Source source) {
-    this._source = source;
-  }
-
-  /**
    * Set the top-level variables contained in this compilation unit to the given variables.
    *
    * @param variables the top-level variables contained in this compilation unit
    */
   void set topLevelVariables(List<TopLevelVariableElement> variables) {
     for (TopLevelVariableElement field in variables) {
       (field as TopLevelVariableElementImpl).enclosingElement = this;
     }
     this._variables = variables;
   }
@@ skipping 15 matching lines @@
    *
    * @param types types contained in this compilation unit
    */
   void set types(List<ClassElement> types) {
     for (ClassElement type in types) {
       (type as ClassElementImpl).enclosingElement = this;
     }
     this._types = types;
   }
 
-  /**
-   * Set the URI that is specified by the "part" directive in the enclosing library.
-   *
-   * @param uri the URI that is specified by the "part" directive in the enclosing library.
-   */
-  void set uri(String uri) {
-    this._uri = uri;
-  }
-
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
-    if (_source == null) {
+    if (source == null) {
       builder.append("{compilation unit}");
     } else {
-      builder.append(_source.fullName);
+      builder.append(source.fullName);
     }
   }
 
   String get identifier => source.encoding;
 }
 
 /**
  * Instances of the class `ConstFieldElementImpl` implement a `FieldElement` for a
  * 'const' field that has an initializer.
  */
@@ skipping 74 matching lines @@
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
    * An empty array of constructor elements.
    */
   static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>(0);
 
   /**
    * The constructor to which this constructor is redirecting.
    */
-  ConstructorElement _redirectedConstructor;
+  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);
 
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
-  ConstructorElement get redirectedConstructor => _redirectedConstructor;
-
   bool get isConst => hasModifier(Modifier.CONST);
 
   bool get isDefaultConstructor {
     String name = this.name;
     if (name != null && name.length != 0) {
       return false;
     }
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
         return false;
@@ skipping 17 matching lines @@
 
   /**
    * Set whether this constructor represents a factory method to the given value.
    *
    * @param isFactory `true` if this constructor represents a factory method
    */
   void set factory(bool isFactory) {
     setModifier(Modifier.FACTORY, isFactory);
   }
 
-  /**
-   * Sets the constructor to which this constructor is redirecting.
-   *
-   * @param redirectedConstructor the constructor to which this constructor is redirecting
-   */
-  void set redirectedConstructor(ConstructorElement redirectedConstructor) {
-    this._redirectedConstructor = redirectedConstructor;
-  }
-
   void appendTo(JavaStringBuilder builder) {
     builder.append(enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
       builder.append(".");
       builder.append(name);
     }
     super.appendTo(builder);
   }
 }
@@ skipping 85 matching lines @@
 
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
  *
  * @coverage dart.engine.element
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
-  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;
-  }
-
-  Element get element => _element;
+  ElementAnnotationImpl(this.element);
 
   bool get isDeprecated {
-    if (_element != null) {
-      LibraryElement library = _element.library;
+    if (element != null) {
+      LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
-        if (_element is ConstructorElement) {
-          ConstructorElement constructorElement = _element as ConstructorElement;
+        if (element is ConstructorElement) {
+          ConstructorElement constructorElement = element as ConstructorElement;
           if (constructorElement.enclosingElement.name == _DEPRECATED_CLASS_NAME) {
             return true;
           }
-        } else if (_element is PropertyAccessorElement && _element.name == _DEPRECATED_VARIABLE_NAME) {
+        } else if (element is PropertyAccessorElement && element.name == _DEPRECATED_VARIABLE_NAME) {
           return true;
         }
       }
     }
     return false;
   }
 
   bool get isOverride {
-    if (_element != null) {
-      LibraryElement library = _element.library;
+    if (element != null) {
+      LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
-        if (_element is PropertyAccessorElement && _element.name == _OVERRIDE_VARIABLE_NAME) {
+        if (element is PropertyAccessorElement && element.name == _OVERRIDE_VARIABLE_NAME) {
           return true;
         }
       }
     }
     return false;
   }
 
   bool get isProxy {
-    if (_element != null) {
-      LibraryElement library = _element.library;
+    if (element != null) {
+      LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
-        if (_element is PropertyAccessorElement && _element.name == _PROXY_VARIABLE_NAME) {
+        if (element is PropertyAccessorElement && element.name == _PROXY_VARIABLE_NAME) {
           return true;
         }
       }
     }
     return false;
   }
 
-  String toString() => "@${_element.toString()}";
+  String toString() => "@${element.toString()}";
 }
 
 /**
  * The abstract class `ElementImpl` implements the behavior common to objects that implement
  * an [Element].
  *
  * @coverage dart.engine.element
  */
 abstract class ElementImpl implements Element {
   /**
    * The enclosing element of this element, or `null` if this element is at the root of the
    * element structure.
    */
   ElementImpl _enclosingElement;
 
   /**
    * The name of this element.
    */
   String _name;
 
   /**
    * The offset of the name of this element in the file that contains the declaration of this
    * element.
    */
-  int _nameOffset = 0;
+  int nameOffset = 0;
 
   /**
    * A bit-encoded form of the modifiers associated with this element.
    */
   int _modifiers = 0;
 
   /**
    * An array containing all of the metadata associated with this element.
    */
-  List<ElementAnnotation> _metadata = ElementAnnotationImpl.EMPTY_ARRAY;
+  List<ElementAnnotation> metadata = ElementAnnotationImpl.EMPTY_ARRAY;
 
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode = 0;
 
   /**
    * Initialize a newly created element to have the given name.
    *
    * @param name the name of this element
    */
   ElementImpl.con1(Identifier name) : this.con2(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.con2(String name, int nameOffset) {
+  ElementImpl.con2(String name, this.nameOffset) {
     this._name = StringUtilities.intern(name);
-    this._nameOffset = nameOffset;
   }
 
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
 
@@ skipping 32 matching lines @@
   }
 
   String get displayName => _name;
 
   Element get enclosingElement => _enclosingElement;
 
   LibraryElement get library => getAncestor(LibraryElement);
 
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
-  List<ElementAnnotation> get metadata => _metadata;
-
   String get name => _name;
 
-  int get nameOffset => _nameOffset;
-
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
 
   int get hashCode {
     if (_cachedHashCode == 0) {
       _cachedHashCode = location.hashCode;
     }
     return _cachedHashCode;
   }
 
   bool isAccessibleIn(LibraryElement library) {
     if (Identifier.isPrivateName(_name)) {
       return library == this.library;
     }
     return true;
   }
 
   bool get isDeprecated {
-    for (ElementAnnotation annotation in _metadata) {
+    for (ElementAnnotation annotation in metadata) {
       if (annotation.isDeprecated) {
         return true;
       }
     }
     return false;
   }
 
   bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
 
   /**
-   * Set the metadata associate with this element to the given array of annotations.
-   *
-   * @param metadata the metadata to be associated with this element
-   */
-  void set metadata(List<ElementAnnotation> metadata) {
-    this._metadata = metadata;
-  }
-
-  /**
-   * Set the offset of the name of this element in the file that contains the declaration of this
-   * element to the given value. This is normally done via the constructor, but this method is
-   * provided to support unnamed constructors.
-   *
-   * @param nameOffset the offset to the beginning of the name
-   */
-  void set nameOffset(int nameOffset) {
-    this._nameOffset = nameOffset;
-  }
-
-  /**
    * Set whether this element is synthetic to correspond to the given value.
    *
    * @param isSynthetic `true` if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
@@ skipping 84 matching lines @@
 
 /**
  * Instances of the class `ElementLocationImpl` implement an [ElementLocation].
  *
  * @coverage dart.engine.element
  */
 class ElementLocationImpl implements ElementLocation {
   /**
    * The path to the element whose location is represented by this object.
    */
-  List<String> components;
+  List<String> _components;
 
   /**
    * The character used to separate components in the encoded form.
    */
   static int _SEPARATOR_CHAR = 0x3B;
 
   /**
    * Initialize a newly created location to represent the given element.
    *
    * @param element the element whose location is being represented
    */
   ElementLocationImpl.con1(Element element) {
     List<String> components = new List<String>();
     Element ancestor = element;
     while (ancestor != null) {
       components.insert(0, (ancestor as ElementImpl).identifier);
       ancestor = ancestor.enclosingElement;
     }
-    this.components = new List.from(components);
+    this._components = new List.from(components);
   }
 
   /**
    * Initialize a newly created location from the given encoded form.
    *
    * @param encoding the encoded form of a location
    */
   ElementLocationImpl.con2(String encoding) {
-    this.components = decode(encoding);
+    this._components = decode(encoding);
   }
 
   bool operator ==(Object object) {
     if (identical(this, object)) {
       return true;
     }
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
-    List<String> otherComponents = location.components;
-    int length = components.length;
+    List<String> otherComponents = location._components;
+    int length = _components.length;
     if (otherComponents.length != length) {
       return false;
     }
     for (int i = length - 1; i >= 2; i--) {
-      if (components[i] != otherComponents[i]) {
+      if (_components[i] != otherComponents[i]) {
         return false;
       }
     }
-    if (length > 1 && !equalSourceComponents(components[1], otherComponents[1])) {
+    if (length > 1 && !equalSourceComponents(_components[1], otherComponents[1])) {
       return false;
     }
-    if (length > 0 && !equalSourceComponents(components[0], otherComponents[0])) {
+    if (length > 0 && !equalSourceComponents(_components[0], otherComponents[0])) {
       return false;
     }
     return true;
   }
 
+  /**
+   * Return the path to the element whose location is represented by this object.
+   *
+   * @return the path to the element whose location is represented by this object
+   */
+  List<String> get components => _components;
+
   String get encoding {
     JavaStringBuilder builder = new JavaStringBuilder();
-    int length = components.length;
+    int length = _components.length;
     for (int i = 0; i < length; i++) {
       if (i > 0) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
-      encode(builder, components[i]);
+      encode(builder, _components[i]);
     }
     return builder.toString();
   }
 
   int get hashCode {
     int result = 1;
-    for (int i = 0; i < components.length; i++) {
-      String component = components[i];
+    for (int i = 0; i < _components.length; i++) {
+      String component = _components[i];
       int componentHash;
       if (i <= 1) {
         componentHash = hashSourceComponent(component);
       } else {
         componentHash = component.hashCode;
       }
       result = 31 * result + componentHash;
     }
     return result;
   }
@@ skipping 151 matching lines @@
   List<LocalVariableElement> _localVariables = LocalVariableElementImpl.EMPTY_ARRAY;
 
   /**
    * An array containing all of the parameters defined by this executable element.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The return type defined by this executable element.
    */
-  Type2 _returnType;
+  Type2 returnType;
 
   /**
    * The type of function defined by this executable element.
    */
-  FunctionType _type;
+  FunctionType type;
 
   /**
    * 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
@@ skipping 34 matching lines @@
   }
 
   List<FunctionElement> get functions => _functions;
 
   List<LabelElement> get labels => _labels;
 
   List<LocalVariableElement> get localVariables => _localVariables;
 
   List<ParameterElement> get parameters => _parameters;
 
-  Type2 get returnType => _returnType;
-
-  FunctionType get type => _type;
-
   bool get isOperator => false;
 
   /**
    * Set the functions defined within this executable element to the given functions.
    *
    * @param functions the functions defined within this executable element
    */
   void set functions(List<FunctionElement> functions) {
     for (FunctionElement function in functions) {
       (function as FunctionElementImpl).enclosingElement = this;
@@ skipping 30 matching lines @@
    *
    * @param parameters the parameters defined by this executable element
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
-  /**
-   * Set the return type defined by this executable element.
-   *
-   * @param returnType the return type defined by this executable element
-   */
-  void set returnType(Type2 returnType) {
-    this._returnType = returnType;
-  }
-
-  /**
-   * Set the type of function defined by this executable element to the given type.
-   *
-   * @param type the type of function defined by this executable element
-   */
-  void set type(FunctionType type) {
-    this._type = type;
-  }
-
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_labels, visitor);
     safelyVisitChildren(_localVariables, visitor);
     safelyVisitChildren(_parameters, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
     builder.append("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       (_parameters[i] as ParameterElementImpl).appendTo(builder);
     }
     builder.append(")");
-    if (_type != null) {
+    if (type != null) {
       builder.append(Element.RIGHT_ARROW);
-      builder.append(_type.returnType);
+      builder.append(type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `ExportElementImpl` implement an [ExportElement].
  *
  * @coverage dart.engine.element
  */
 class ExportElementImpl extends ElementImpl implements ExportElement {
   /**
    * The URI that is specified by this directive.
    */
-  String _uri;
+  String uri;
 
   /**
    * The library that is exported from this library by this export directive.
    */
-  LibraryElement _exportedLibrary;
+  LibraryElement exportedLibrary;
 
   /**
    * The combinators that were specified as part of the export directive in the order in which they
    * were specified.
    */
-  List<NamespaceCombinator> _combinators = NamespaceCombinator.EMPTY_ARRAY;
+  List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created export element.
    */
   ExportElementImpl() : super.con1(null);
 
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
 
-  List<NamespaceCombinator> get combinators => _combinators;
-
-  LibraryElement get exportedLibrary => _exportedLibrary;
-
   ElementKind get kind => ElementKind.EXPORT;
 
-  String get uri => _uri;
-
-  /**
-   * Set the combinators that were specified as part of the export directive to the given array of
-   * combinators.
-   *
-   * @param combinators the combinators that were specified as part of the export directive
-   */
-  void set combinators(List<NamespaceCombinator> combinators) {
-    this._combinators = combinators;
-  }
-
-  /**
-   * Set the library that is exported from this library by this import directive to the given
-   * library.
-   *
-   * @param exportedLibrary the library that is exported from this library
-   */
-  void set exportedLibrary(LibraryElement exportedLibrary) {
-    this._exportedLibrary = exportedLibrary;
-  }
-
-  /**
-   * Set the URI that is specified by this directive.
-   *
-   * @param uri the URI that is specified by this directive.
-   */
-  void set uri(String uri) {
-    this._uri = uri;
-  }
-
   void appendTo(JavaStringBuilder builder) {
     builder.append("export ");
-    (_exportedLibrary as LibraryElementImpl).appendTo(builder);
+    (exportedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
-  String get identifier => _exportedLibrary.name;
+  String get identifier => exportedLibrary.name;
 }
 
 /**
  * Instances of the class `ExternalHtmlScriptElementImpl` implement an
  * [ExternalHtmlScriptElement].
  *
  * @coverage dart.engine.element
  */
 class ExternalHtmlScriptElementImpl extends HtmlScriptElementImpl implements ExternalHtmlScriptElement {
   /**
    * The source specified in the `source` attribute or `null` if unspecified.
    */
-  Source _scriptSource;
+  Source scriptSource;
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node);
 
   accept(ElementVisitor visitor) => visitor.visitExternalHtmlScriptElement(this);
 
   ElementKind get kind => ElementKind.EXTERNAL_HTML_SCRIPT;
-
-  Source get scriptSource => _scriptSource;
-
-  /**
-   * Set the source specified in the `source` attribute.
-   *
-   * @param scriptSource the script source or `null` if unspecified
-   */
-  void set scriptSource(Source scriptSource) {
-    this._scriptSource = scriptSource;
-  }
 }
 
 /**
  * Instances of the class `FieldElementImpl` implement a `FieldElement`.
  *
  * @coverage dart.engine.element
  */
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
   /**
    * An empty array of field elements.
@@ skipping 36 matching lines @@
  * Instances of the class `FieldFormalParameterElementImpl` extend
  * [ParameterElementImpl] to provide the additional information of the [FieldElement]
  * associated with the parameter.
  *
  * @coverage dart.engine.element
  */
 class FieldFormalParameterElementImpl extends ParameterElementImpl implements FieldFormalParameterElement {
   /**
    * The field associated with this field formal parameter.
    */
-  FieldElement _field;
+  FieldElement field;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   FieldFormalParameterElementImpl(Identifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
 
-  FieldElement get field => _field;
-
   bool get isInitializingFormal => true;
-
-  /**
-   * Set the field element associated with this field formal parameter to the given element.
-   *
-   * @param field the new field element
-   */
-  void set field(FieldElement field) {
-    this._field = field;
-  }
 }
 
 /**
  * Instances of the class `FunctionElementImpl` implement a `FunctionElement`.
  *
  * @coverage dart.engine.element
  */
 class FunctionElementImpl extends ExecutableElementImpl implements FunctionElement {
   /**
    * The offset to the beginning of the visible range for this element.
@@ skipping 72 matching lines @@
  */
 class FunctionTypeAliasElementImpl extends ElementImpl implements FunctionTypeAliasElement {
   /**
    * An array containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The return type defined by this type alias.
    */
-  Type2 _returnType;
+  Type2 returnType;
 
   /**
    * The type of function defined by this type alias.
    */
-  FunctionType _type;
+  FunctionType type;
 
   /**
    * An array containing all of the type parameters defined for this type.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * An empty array of type alias elements.
    */
   static List<FunctionTypeAliasElement> EMPTY_ARRAY = new List<FunctionTypeAliasElement>(0);
@@ skipping 20 matching lines @@
     }
     return null;
   }
 
   CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
 
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   List<ParameterElement> get parameters => _parameters;
 
-  Type2 get returnType => _returnType;
-
-  FunctionType get type => _type;
-
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the parameters defined by this type alias to the given parameters.
    *
    * @param parameters the parameters defined by this type alias
    */
   void set parameters(List<ParameterElement> parameters) {
     if (parameters != null) {
       for (ParameterElement parameter in parameters) {
         (parameter as ParameterElementImpl).enclosingElement = this;
       }
     }
     this._parameters = parameters;
   }
 
   /**
-   * Set the return type defined by this type alias.
-   *
-   * @param returnType the return type defined by this type alias
-   */
-  void set returnType(Type2 returnType) {
-    this._returnType = returnType;
-  }
-
-  /**
-   * Set the type of function defined by this type alias to the given type.
-   *
-   * @param type the type of function defined by this type alias
-   */
-  void set type(FunctionType type) {
-    this._type = type;
-  }
-
-  /**
    * Set the type parameters defined for this type to the given parameters.
    *
    * @param typeParameters the type parameters defined for this type
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameters = typeParameters;
   }
@@ skipping 42 matching lines @@
     }
     builder.append("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       (_parameters[i] as ParameterElementImpl).appendTo(builder);
     }
     builder.append(")");
-    if (_type != null) {
+    if (type != null) {
       builder.append(Element.RIGHT_ARROW);
-      builder.append(_type.returnType);
+      builder.append(type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `HideElementCombinatorImpl` implement a
  * [HideElementCombinator].
  *
  * @coverage dart.engine.element
  */
 class HideElementCombinatorImpl implements HideElementCombinator {
   /**
    * The names that are not to be made visible in the importing library even if they are defined in
    * the imported library.
    */
-  List<String> _hiddenNames = StringUtilities.EMPTY_ARRAY;
-
-  List<String> get hiddenNames => _hiddenNames;
-
-  /**
-   * Set the names that are not to be made visible in the importing library even if they are defined
-   * in the imported library to the given names.
-   *
-   * @param hiddenNames the names that are not to be made visible in the importing library
-   */
-  void set hiddenNames(List<String> hiddenNames) {
-    this._hiddenNames = hiddenNames;
-  }
+  List<String> hiddenNames = StringUtilities.EMPTY_ARRAY;
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("show ");
-    int count = _hiddenNames.length;
+    int count = hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
-      builder.append(_hiddenNames[i]);
+      builder.append(hiddenNames[i]);
     }
     return builder.toString();
   }
 }
 
 /**
  * Instances of the class `HtmlElementImpl` implement an [HtmlElement].
  *
  * @coverage dart.engine.element
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty array of HTML file elements.
    */
   static List<HtmlElement> EMPTY_ARRAY = new List<HtmlElement>(0);
 
   /**
    * The analysis context in which this library is defined.
    */
-  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;
+  Source source;
 
   /**
    * 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.con2(name, -1) {
-    this._context = context;
-  }
+  HtmlElementImpl(this.context, String name) : super.con2(name, -1);
 
   accept(ElementVisitor visitor) => visitor.visitHtmlElement(this);
 
-  bool operator ==(Object object) => runtimeType == object.runtimeType && _source == (object as CompilationUnitElementImpl).source;
-
-  AnalysisContext get context => _context;
+  bool operator ==(Object object) => runtimeType == object.runtimeType && source == (object as CompilationUnitElementImpl).source;
 
   ElementKind get kind => ElementKind.HTML;
 
   List<HtmlScriptElement> get scripts => _scripts;
 
-  Source get source => _source;
-
-  int get hashCode => _source.hashCode;
+  int get hashCode => source.hashCode;
 
   /**
    * Set the scripts contained in the HTML file to the given scripts.
    *
    * @param scripts the scripts
    */
   void set scripts(List<HtmlScriptElement> scripts) {
     if (scripts.length == 0) {
       scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
     }
     for (HtmlScriptElement script in scripts) {
       (script as HtmlScriptElementImpl).enclosingElement = this;
     }
     this._scripts = scripts;
   }
 
-  /**
-   * Set the source that corresponds to this HTML file to the given source.
-   *
-   * @param source the source that corresponds to this HTML file
-   */
-  void set source(Source source) {
-    this._source = source;
-  }
-
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
-    if (_source == null) {
+    if (source == null) {
       builder.append("{HTML file}");
     } else {
-      builder.append(_source.fullName);
+      builder.append(source.fullName);
     }
   }
 }
 
 /**
  * Instances of the class `HtmlScriptElementImpl` implement an [HtmlScriptElement].
  *
  * @coverage dart.engine.element
  */
 abstract class HtmlScriptElementImpl extends ElementImpl implements HtmlScriptElement {
@@ skipping 18 matching lines @@
 class ImportElementImpl extends ElementImpl implements ImportElement {
   /**
    * The offset of this directive, may be `-1` if synthetic.
    */
   int _offset = -1;
 
   /**
    * The offset of the character immediately following the last character of this node's URI, may be
    * `-1` if synthetic.
    */
-  int _uriEnd = -1;
+  int uriEnd = -1;
 
   /**
    * The offset of the prefix of this import in the file that contains the this import directive, or
    * `-1` if this import is synthetic.
    */
-  int _prefixOffset = 0;
+  int prefixOffset = 0;
 
   /**
    * The URI that is specified by this directive.
    */
-  String _uri;
+  String uri;
 
   /**
    * The library that is imported into this library by this import directive.
    */
-  LibraryElement _importedLibrary;
+  LibraryElement importedLibrary;
 
   /**
    * The combinators that were specified as part of the import directive in the order in which they
    * were specified.
    */
-  List<NamespaceCombinator> _combinators = NamespaceCombinator.EMPTY_ARRAY;
+  List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
 
   /**
    * The prefix that was specified as part of the import directive, or `null` if there was no
    * prefix specified.
    */
-  PrefixElement _prefix;
+  PrefixElement prefix;
 
   /**
    * Initialize a newly created import element.
    */
   ImportElementImpl() : super.con1(null);
 
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
 
-  List<NamespaceCombinator> get combinators => _combinators;
-
-  LibraryElement get importedLibrary => _importedLibrary;
-
   ElementKind get kind => ElementKind.IMPORT;
 
-  PrefixElement get prefix => _prefix;
-
-  int get prefixOffset => _prefixOffset;
-
-  String get uri => _uri;
-
-  int get uriEnd => _uriEnd;
-
-  /**
-   * Set the combinators that were specified as part of the import directive to the given array of
-   * combinators.
-   *
-   * @param combinators the combinators that were specified as part of the import directive
-   */
-  void set combinators(List<NamespaceCombinator> combinators) {
-    this._combinators = combinators;
-  }
-
-  /**
-   * Set the library that is imported into this library by this import directive to the given
-   * library.
-   *
-   * @param importedLibrary the library that is imported into this library
-   */
-  void set importedLibrary(LibraryElement importedLibrary) {
-    this._importedLibrary = importedLibrary;
-  }
-
   /**
    * Set the offset of this directive.
    */
   void set offset(int offset) {
     this._offset = offset;
   }
 
-  /**
-   * Set the prefix that was specified as part of the import directive to the given prefix.
-   *
-   * @param prefix the prefix that was specified as part of the import directive
-   */
-  void set prefix(PrefixElement prefix) {
-    this._prefix = prefix;
-  }
-
-  /**
-   * Set the offset of the prefix of this import in the file that contains the this import
-   * directive.
-   */
-  void set prefixOffset(int prefixOffset) {
-    this._prefixOffset = prefixOffset;
-  }
-
-  /**
-   * Set the URI that is specified by this directive.
-   *
-   * @param uri the URI that is specified by this directive.
-   */
-  void set uri(String uri) {
-    this._uri = uri;
-  }
-
-  /**
-   * Set the the offset of the character immediately following the last character of this node's
-   * URI. `-1` for synthetic import.
-   */
-  void set uriEnd(int uriEnd) {
-    this._uriEnd = uriEnd;
-  }
-
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
-    safelyVisitChild(_prefix, visitor);
+    safelyVisitChild(prefix, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
-    (_importedLibrary as LibraryElementImpl).appendTo(builder);
+    (importedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
-  String get identifier => "${(_importedLibrary as LibraryElementImpl).identifier}@${_offset}";
+  String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${_offset}";
 }
 
 /**
  * Instances of the class `LabelElementImpl` implement a `LabelElement`.
  *
  * @coverage dart.engine.element
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch` statement.
    */
-  bool isOnSwitchStatement = false;
+  bool _onSwitchStatement = false;
 
   /**
    * A flag indicating whether this label is associated with a `switch` member (`case`
    * or `default`).
    */
-  bool isOnSwitchMember = false;
+  bool _onSwitchMember = false;
 
   /**
    * 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.con1(name) {
-    this.isOnSwitchStatement = onSwitchStatement;
-    this.isOnSwitchMember = onSwitchMember;
+    this._onSwitchStatement = onSwitchStatement;
+    this._onSwitchMember = onSwitchMember;
   }
 
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
 
   ExecutableElement get enclosingElement => super.enclosingElement as ExecutableElement;
 
   ElementKind get kind => ElementKind.LABEL;
+
+  /**
+   * Return `true` if this label is associated with a `switch` member (`case` or
+   * `default`).
+   *
+   * @return `true` if this label is associated with a `switch` member
+   */
+  bool get isOnSwitchMember => _onSwitchMember;
+
+  /**
+   * Return `true` if this label is associated with a `switch` statement.
+   *
+   * @return `true` if this label is associated with a `switch` statement
+   */
+  bool get isOnSwitchStatement => _onSwitchStatement;
 }
 
 /**
  * Instances of the class `LibraryElementImpl` implement a `LibraryElement`.
  *
  * @coverage dart.engine.element
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
    * An empty array of library elements.
@@ skipping 28 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;
+  FunctionElement entryPoint;
 
   /**
    * An array containing specifications of all of the imports defined in this library.
    */
   List<ImportElement> _imports = ImportElement.EMPTY_ARRAY;
 
   /**
    * An array containing specifications of all of the exports defined in this library.
    */
   List<ExportElement> _exports = ExportElement.EMPTY_ARRAY;
 
   /**
    * An array containing all of the compilation units that are included in this library using a
    * `part` directive.
    */
   List<CompilationUnitElement> _parts = CompilationUnitElementImpl.EMPTY_ARRAY;
 
   /**
    * 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.con1(name) {
-    this._context = context;
-  }
+  LibraryElementImpl(this.context, LibraryIdentifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _definingCompilationUnit == (object as LibraryElementImpl).definingCompilationUnit;
 
   ElementImpl getChild(String identifier) {
     if ((_definingCompilationUnit as CompilationUnitElementImpl).identifier == identifier) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
       if ((part as CompilationUnitElementImpl).identifier == identifier) {
         return part as CompilationUnitElementImpl;
       }
     }
     for (ImportElement importElement in _imports) {
       if ((importElement as ImportElementImpl).identifier == identifier) {
         return importElement as ImportElementImpl;
       }
     }
     for (ExportElement exportElement in _exports) {
       if ((exportElement as ExportElementImpl).identifier == identifier) {
         return exportElement as ExportElementImpl;
       }
     }
     return null;
   }
 
-  AnalysisContext get context => _context;
-
   CompilationUnitElement get definingCompilationUnit => _definingCompilationUnit;
 
-  FunctionElement get entryPoint => _entryPoint;
-
   List<LibraryElement> get exportedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ExportElement element in _exports) {
       LibraryElement library = element.exportedLibrary;
       if (library != null) {
         libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
@@ skipping 46 matching lines @@
       type = part.getType(className);
       if (type != null) {
         return type;
       }
     }
     return null;
   }
 
   int get hashCode => _definingCompilationUnit.hashCode;
 
-  bool get isBrowserApplication => _entryPoint != null && isOrImportsBrowserLibrary;
+  bool get isBrowserApplication => entryPoint != null && isOrImportsBrowserLibrary;
 
   bool get isDartCore => name == "dart.core";
 
   bool get isInSdk => name.startsWith("dart.");
 
   bool isUpToDate2(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
     return isUpToDate(this, timeStamp, visitedLibraries);
   }
 
   /**
    * Set the compilation unit that defines this library to the given compilation unit.
    *
    * @param definingCompilationUnit the compilation unit that defines this library
    */
   void set definingCompilationUnit(CompilationUnitElement definingCompilationUnit) {
     (definingCompilationUnit as CompilationUnitElementImpl).enclosingElement = this;
     this._definingCompilationUnit = definingCompilationUnit;
   }
 
   /**
-   * Set the entry point for this library to the given function.
-   *
-   * @param entryPoint the entry point for this library
-   */
-  void set entryPoint(FunctionElement entryPoint) {
-    this._entryPoint = entryPoint;
-  }
-
-  /**
    * Set the specifications of all of the exports defined in this library to the given array.
    *
    * @param exports the specifications of all of the exports defined in this library
    */
   void set exports(List<ExportElement> exports) {
     for (ExportElement exportElement in exports) {
       (exportElement as ExportElementImpl).enclosingElement = this;
     }
     this._exports = exports;
   }
@@ skipping 37 matching lines @@
 
   String get identifier => _definingCompilationUnit.source.encoding;
 
   /**
    * 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);
+    Source htmlLibSource = context.sourceFactory.forUri(DartSdk.DART_HTML);
     visited.add(this);
     for (int index = 0; index < visited.length; index++) {
       LibraryElement library = visited[index];
       Source source = library.definingCompilationUnit.source;
       if (source == htmlLibSource) {
         return true;
       }
       for (LibraryElement importedLibrary in library.importedLibraries) {
         if (!visited.contains(importedLibrary)) {
           visited.add(importedLibrary);
@@ skipping 253 matching lines @@
 
   /**
    * Add the given element to the list of elements. If the element is a multiply-defined element,
    * add all of the conflicting elements that it represents.
    *
    * @param elements the list to which the element(s) are to be added
    * @param element the element(s) to be added
    */
   static void add(Set<Element> elements, Element element) {
     if (element is MultiplyDefinedElementImpl) {
-      for (Element conflictingElement in (element as MultiplyDefinedElementImpl)._conflictingElements) {
+      for (Element conflictingElement in (element as MultiplyDefinedElementImpl).conflictingElements) {
         elements.add(conflictingElement);
       }
     } else {
       elements.add(element);
     }
   }
 
   /**
    * Use the given elements to construct an array of conflicting elements. If either of the given
    * elements are multiply-defined elements then the conflicting elements they represent will be
    * included in the array. Otherwise, the element itself will be included.
    *
    * @param firstElement the first element to be included
    * @param secondElement the second element to be included
    * @return an array containing all of the conflicting elements
    */
   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;
   }
 
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
 
   String computeDocumentationComment() => null;
 
   Element getAncestor(Type elementClass) => null;
 
-  List<Element> get conflictingElements => _conflictingElements;
-
-  AnalysisContext get context => _context;
-
   String get displayName => _name;
 
   Element get enclosingElement => null;
 
   ElementKind get kind => ElementKind.ERROR;
 
   LibraryElement get library => null;
 
   ElementLocation get location => null;
 
   List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
 
   String get name => _name;
 
   int get nameOffset => -1;
 
   Source get source => null;
 
   Type2 get type => DynamicTypeImpl.instance;
 
   bool isAccessibleIn(LibraryElement library) {
-    for (Element element in _conflictingElements) {
+    for (Element element in conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
 
   bool get isDeprecated => false;
 
   bool get isSynthetic => true;
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("[");
-    int count = _conflictingElements.length;
+    int count = conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
-      (_conflictingElements[i] as ElementImpl).appendTo(builder);
+      (conflictingElements[i] as ElementImpl).appendTo(builder);
     }
     builder.append("]");
     return builder.toString();
   }
 
   void visitChildren(ElementVisitor visitor) {
   }
 }
 
 /**
@@ skipping 14 matching lines @@
 
   /**
    * An array containing all of the parameters defined by this parameter element. There will only be
    * parameters if this parameter is a function typed parameter.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The kind of this parameter.
    */
-  ParameterKind _parameterKind;
+  ParameterKind parameterKind;
 
   /**
    * The offset to the beginning of the default value range for this element.
    */
   int _defaultValueRangeOffset = 0;
 
   /**
    * The length of the default value range for this element, or `-1` if this element does not
    * have a default value.
    */
@@ skipping 35 matching lines @@
 
   SourceRange get defaultValueRange {
     if (_defaultValueRangeLength < 0) {
       return null;
     }
     return new SourceRange(_defaultValueRangeOffset, _defaultValueRangeLength);
   }
 
   ElementKind get kind => ElementKind.PARAMETER;
 
-  ParameterKind get parameterKind => _parameterKind;
-
   List<ParameterElement> get parameters => _parameters;
 
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   bool get isInitializingFormal => false;
@@ skipping 23 matching lines @@
    * @param offset the offset to the beginning of the default value range for this element
    * @param length the length of the default value range for this element, or `-1` if this
    *          element does not have a default value
    */
   void setDefaultValueRange(int offset, int length) {
     _defaultValueRangeOffset = offset;
     _defaultValueRangeLength = length;
   }
 
   /**
-   * Set the kind of this parameter to the given kind.
-   *
-   * @param parameterKind the new kind of this parameter
-   */
-  void set parameterKind(ParameterKind parameterKind) {
-    this._parameterKind = parameterKind;
-  }
-
-  /**
    * Set the parameters defined by this executable element to the given parameters.
    *
    * @param parameters the parameters defined by this executable element
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
@@ skipping 91 matching lines @@
 /**
  * Instances of the class `PropertyAccessorElementImpl` implement a
  * `PropertyAccessorElement`.
  *
  * @coverage dart.engine.element
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
   /**
    * The variable associated with this accessor.
    */
-  PropertyInducingElement _variable;
+  PropertyInducingElement variable;
 
   /**
    * 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);
 
   /**
    * 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) {
-    this._variable = variable;
+    this.variable = variable;
     synthetic = true;
   }
 
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
   bool operator ==(Object object) => super == object && identical(isGetter, (object as PropertyAccessorElement).isGetter);
 
   PropertyAccessorElement get correspondingGetter {
-    if (isGetter || _variable == null) {
+    if (isGetter || variable == null) {
       return null;
     }
-    return _variable.getter;
+    return variable.getter;
   }
 
   PropertyAccessorElement get correspondingSetter {
-    if (isSetter || _variable == null) {
+    if (isSetter || variable == null) {
       return null;
     }
-    return _variable.setter;
+    return variable.setter;
   }
 
   ElementKind get kind {
     if (isGetter) {
       return ElementKind.GETTER;
     }
     return ElementKind.SETTER;
   }
 
   String get name {
     if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
 
-  PropertyInducingElement get variable => _variable;
-
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
   bool get isGetter => hasModifier(Modifier.GETTER);
 
   bool get isSetter => hasModifier(Modifier.SETTER);
 
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this accessor is abstract to correspond to the given value.
@@ skipping 24 matching lines @@
 
   /**
    * Set whether this accessor is static to correspond to the given value.
    *
    * @param isStatic `true` if the accessor is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
-  /**
-   * Set the variable associated with this accessor to the given variable.
-   *
-   * @param variable the variable associated with this accessor
-   */
-  void set variable(PropertyInducingElement variable) {
-    this._variable = variable;
-  }
-
   void appendTo(JavaStringBuilder builder) {
     builder.append(isGetter ? "get " : "set ");
     builder.append(variable.displayName);
     super.appendTo(builder);
   }
 }
 
 /**
  * Instances of the class `PropertyInducingElementImpl` implement a
  * `PropertyInducingElement`.
  *
  * @coverage dart.engine.element
  */
 abstract class PropertyInducingElementImpl extends VariableElementImpl implements PropertyInducingElement {
   /**
    * The getter associated with this element.
    */
-  PropertyAccessorElement _getter;
+  PropertyAccessorElement getter;
 
   /**
    * The setter associated with this element, or `null` if the element is effectively
    * `final` and therefore does not have a setter associated with it.
    */
-  PropertyAccessorElement _setter;
+  PropertyAccessorElement setter;
 
   /**
    * 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);
 
   /**
    * 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) {
     synthetic = true;
   }
-
-  PropertyAccessorElement get getter => _getter;
-
-  PropertyAccessorElement get setter => _setter;
-
-  /**
-   * Set the getter associated with this element to the given accessor.
-   *
-   * @param getter the getter associated with this element
-   */
-  void set getter(PropertyAccessorElement getter) {
-    this._getter = getter;
-  }
-
-  /**
-   * Set the setter associated with this element to the given accessor.
-   *
-   * @param setter the setter associated with this element
-   */
-  void set setter(PropertyAccessorElement setter) {
-    this._setter = setter;
-  }
 }
 
 /**
  * Instances of the class `ShowElementCombinatorImpl` implement a
  * [ShowElementCombinator].
  *
  * @coverage dart.engine.element
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
   /**
    * The names that are to be made visible in the importing library if they are defined in the
    * imported library.
    */
-  List<String> _shownNames = StringUtilities.EMPTY_ARRAY;
+  List<String> shownNames = StringUtilities.EMPTY_ARRAY;
 
   /**
    * The offset of the character immediately following the last character of this node.
    */
-  int _end = -1;
+  int end = -1;
 
   /**
    * The offset of the 'show' keyword of this element.
    */
-  int _offset = 0;
-
-  int get end => _end;
-
-  int get offset => _offset;
-
-  List<String> get shownNames => _shownNames;
-
-  /**
-   * Set the the offset of the character immediately following the last character of this node.
-   */
-  void set end(int endOffset) {
-    this._end = endOffset;
-  }
-
-  /**
-   * Sets the offset of the 'show' keyword of this directive.
-   */
-  void set offset(int offset) {
-    this._offset = offset;
-  }
-
-  /**
-   * Set the names that are to be made visible in the importing library if they are defined in the
-   * imported library to the given names.
-   *
-   * @param shownNames the names that are to be made visible in the importing library
-   */
-  void set shownNames(List<String> shownNames) {
-    this._shownNames = shownNames;
-  }
+  int offset = 0;
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("show ");
-    int count = _shownNames.length;
+    int count = shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
-      builder.append(_shownNames[i]);
+      builder.append(shownNames[i]);
     }
     return builder.toString();
   }
 }
 
 /**
  * Instances of the class `TopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement`.
  *
  * @coverage dart.engine.element
@@ skipping 27 matching lines @@
 
 /**
  * Instances of the class `TypeParameterElementImpl` implement a [TypeParameterElement].
  *
  * @coverage dart.engine.element
  */
 class TypeParameterElementImpl extends ElementImpl implements TypeParameterElement {
   /**
    * The type defined by this type parameter.
    */
-  TypeParameterType _type;
+  TypeParameterType type;
 
   /**
    * The type representing the bound associated with this parameter, or `null` if this
    * parameter does not have an explicit bound.
    */
-  Type2 _bound;
+  Type2 bound;
 
   /**
    * An empty array of type parameter elements.
    */
   static List<TypeParameterElement> EMPTY_ARRAY = new List<TypeParameterElement>(0);
 
   /**
    * Initialize a newly created type parameter element to have the given name.
    *
    * @param name the name of this element
    */
   TypeParameterElementImpl(Identifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
 
-  Type2 get bound => _bound;
-
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
-  TypeParameterType get type => _type;
-
-  /**
-   * Set the type representing the bound associated with this parameter to the given type.
-   *
-   * @param bound the type representing the bound associated with this parameter
-   */
-  void set bound(Type2 bound) {
-    this._bound = bound;
-  }
-
-  /**
-   * Set the type defined by this type parameter to the given type
-   *
-   * @param type the type defined by this type parameter
-   */
-  void set type(TypeParameterType type) {
-    this._type = type;
-  }
-
   void appendTo(JavaStringBuilder builder) {
     builder.append(displayName);
-    if (_bound != null) {
+    if (bound != null) {
       builder.append(" extends ");
-      builder.append(_bound);
+      builder.append(bound);
     }
   }
 }
 
 /**
  * Instances of the class `VariableElementImpl` implement a `VariableElement`.
  *
  * @coverage dart.engine.element
  */
 abstract class VariableElementImpl extends ElementImpl implements VariableElement {
   /**
    * The declared type of this variable.
    */
-  Type2 _type;
+  Type2 type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if this variable
    * does not have an initializer.
    */
   FunctionElement _initializer;
 
   /**
    * An empty array of variable elements.
    */
@@ skipping 19 matching lines @@
    * 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.
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
 
   FunctionElement get initializer => _initializer;
 
-  Type2 get type => _type;
-
   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 closure
    */
@@ skipping 40 matching lines @@
    *
    * @param initializer the function representing this variable's initializer
    */
   void set initializer(FunctionElement initializer) {
     if (initializer != null) {
       (initializer as FunctionElementImpl).enclosingElement = this;
     }
     this._initializer = initializer;
   }
 
-  /**
-   * Set the declared type of this variable to the given type.
-   *
-   * @param type the declared type of this variable
-   */
-  void set type(Type2 type) {
-    this._type = type;
-  }
-
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
 
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
@@ skipping 659 matching lines @@
 
 /**
  * The unique instance of the class `BottomTypeImpl` implements the type `bottom`.
  *
  * @coverage dart.engine.type
  */
 class BottomTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
-  static final BottomTypeImpl instance = new BottomTypeImpl();
+  static BottomTypeImpl _INSTANCE = new BottomTypeImpl();
+
+  /**
+   * Return the unique instance of this class.
+   *
+   * @return the unique instance of this class
+   */
+  static BottomTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   BottomTypeImpl() : super(null, "<bottom>");
 
   bool operator ==(Object object) => identical(object, this);
 
   bool get isBottom => true;
 
   bool isSupertypeOf(Type2 type) => false;
 
   BottomTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 
   bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 
   bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
  * The unique instance of the class `DynamicTypeImpl` implements the type `dynamic`.
  *
  * @coverage dart.engine.type
  */
 class DynamicTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
-  static final DynamicTypeImpl instance = new DynamicTypeImpl();
+  static DynamicTypeImpl _INSTANCE = new DynamicTypeImpl();
+
+  /**
+   * Return the unique instance of this class.
+   *
+   * @return the unique instance of this class
+   */
+  static DynamicTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   DynamicTypeImpl() : super(new DynamicElementImpl(), Keyword.DYNAMIC.syntax) {
     (element as DynamicElementImpl).type = this;
   }
 
   bool operator ==(Object object) => object is DynamicTypeImpl;
 
@@ skipping 50 matching lines @@
       if (firstEntry.getKey() != secondEntry.getKey() || firstEntry.getValue() != secondEntry.getValue()) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * An array containing the actual types of the type arguments.
    */
-  List<Type2> _typeArguments = TypeImpl.EMPTY_ARRAY;
+  List<Type2> typeArguments = TypeImpl.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
   FunctionTypeImpl.con1(ExecutableElement element) : super(element, element == null ? null : element.name);
 
   /**
@@ skipping 82 matching lines @@
 
   Map<String, Type2> get namedParameterTypes {
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return namedParameterTypes;
     }
     List<Type2> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
-        namedParameterTypes[parameter.name] = parameter.type.substitute2(_typeArguments, typeParameters);
+        namedParameterTypes[parameter.name] = parameter.type.substitute2(typeArguments, typeParameters);
       }
     }
     return namedParameterTypes;
   }
 
   List<Type2> get normalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<Type2> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<Type2> types = new List<Type2>();
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
-        types.add(parameter.type.substitute2(_typeArguments, typeParameters));
+        types.add(parameter.type.substitute2(typeArguments, typeParameters));
       }
     }
     return new List.from(types);
   }
 
   List<Type2> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<Type2> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<Type2> types = new List<Type2>();
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.POSITIONAL)) {
-        types.add(parameter.type.substitute2(_typeArguments, typeParameters));
+        types.add(parameter.type.substitute2(typeArguments, typeParameters));
       }
     }
     return new List.from(types);
   }
 
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = this.baseParameters;
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     List<ParameterElement> specializedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       specializedParameters[i] = ParameterMember.from(baseParameters[i], this);
     }
     return specializedParameters;
   }
 
   Type2 get returnType {
     Type2 baseReturnType = this.baseReturnType;
     if (baseReturnType == null) {
       return DynamicTypeImpl.instance;
     }
-    return baseReturnType.substitute2(_typeArguments, TypeParameterTypeImpl.getTypes(typeParameters));
+    return baseReturnType.substitute2(typeArguments, TypeParameterTypeImpl.getTypes(typeParameters));
   }
 
-  List<Type2> get typeArguments => _typeArguments;
-
   List<TypeParameterElement> get typeParameters {
     Element element = this.element;
     if (element is FunctionTypeAliasElement) {
       return (element as FunctionTypeAliasElement).typeParameters;
     }
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
       return definingClass.typeParameters;
     }
     return TypeParameterElementImpl.EMPTY_ARRAY;
@@ skipping 88 matching lines @@
         }
       }
     }
     Type2 tRetType = t.returnType;
     Type2 sRetType = s.returnType;
     return sRetType.isVoid || (tRetType as TypeImpl).isMoreSpecificThan3(sRetType, withDynamic, visitedTypePairs);
   }
 
   bool isAssignableTo(Type2 type) => isSubtypeOf3(type, new Set<TypeImpl_TypePair>());
 
-  /**
-   * Set the actual types of the type arguments to the given types.
-   *
-   * @param typeArguments the actual types of the type arguments
-   */
-  void set typeArguments(List<Type2> typeArguments) {
-    this._typeArguments = typeArguments;
-  }
-
   FunctionTypeImpl substitute3(List<Type2> argumentTypes) => substitute2(argumentTypes, typeArguments);
 
   FunctionTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException("argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0) {
       return this;
     }
     Element element = this.element;
     FunctionTypeImpl newType = (element is ExecutableElement) ? new FunctionTypeImpl.con1(element as ExecutableElement) : new FunctionTypeImpl.con2(element as FunctionTypeAliasElement);
-    newType.typeArguments = TypeImpl.substitute(_typeArguments, argumentTypes, parameterTypes);
+    newType.typeArguments = TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
     return newType;
   }
 
   void appendTo(JavaStringBuilder builder) {
     List<Type2> normalParameterTypes = this.normalParameterTypes;
     List<Type2> optionalParameterTypes = this.optionalParameterTypes;
     Map<String, Type2> namedParameterTypes = this.namedParameterTypes;
     Type2 returnType = this.returnType;
     builder.append("(");
     bool needsComma = false;
@@ skipping 325 matching lines @@
       }
     }
     InterfaceTypeImpl lub = new InterfaceTypeImpl.con1(firstType.element);
     lub.typeArguments = lubArguments;
     return lub;
   }
 
   /**
    * An array containing the actual types of the type arguments.
    */
-  List<Type2> _typeArguments = TypeImpl.EMPTY_ARRAY;
+  List<Type2> typeArguments = TypeImpl.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created type to be declared by the given element.
    *
    * @param element the element representing the declaration of the type
    */
   InterfaceTypeImpl.con1(ClassElement element) : super(element, element.displayName);
 
   /**
    * Initialize a newly created type to have the given name. This constructor should only be used in
    * cases where there is no declaration of the type.
    *
    * @param name the name of the type
    */
   InterfaceTypeImpl.con2(String name) : super(null, name);
 
   bool operator ==(Object object) {
     if (object is! InterfaceTypeImpl) {
       return false;
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
-    return (element == otherType.element) && JavaArrays.equals(_typeArguments, otherType._typeArguments);
+    return (element == otherType.element) && JavaArrays.equals(typeArguments, otherType.typeArguments);
   }
 
   List<PropertyAccessorElement> get accessors {
     List<PropertyAccessorElement> accessors = element.accessors;
     List<PropertyAccessorElement> members = new List<PropertyAccessorElement>(accessors.length);
     for (int i = 0; i < accessors.length; i++) {
       members[i] = PropertyAccessorMember.from(accessors[i], this);
     }
     return members;
   }
@@ skipping 33 matching lines @@
     ClassElement classElement = element;
     List<InterfaceType> interfaces = classElement.interfaces;
     List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<Type2> parameterTypes = classElement.type.typeArguments;
     if (typeParameters.length == 0) {
       return interfaces;
     }
     int count = interfaces.length;
     List<InterfaceType> typedInterfaces = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
-      typedInterfaces[i] = interfaces[i].substitute2(_typeArguments, parameterTypes);
+      typedInterfaces[i] = interfaces[i].substitute2(typeArguments, parameterTypes);
     }
     return typedInterfaces;
   }
 
   Type2 getLeastUpperBound(Type2 type) {
     if (identical(type, this)) {
       return this;
     }
     Type2 dynamicType = DynamicTypeImpl.instance;
     if (identical(this, dynamicType) || identical(type, dynamicType)) {
@@ skipping 48 matching lines @@
     ClassElement classElement = element;
     List<InterfaceType> mixins = classElement.mixins;
     List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<Type2> parameterTypes = classElement.type.typeArguments;
     if (typeParameters.length == 0) {
       return mixins;
     }
     int count = mixins.length;
     List<InterfaceType> typedMixins = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
-      typedMixins[i] = mixins[i].substitute2(_typeArguments, parameterTypes);
+      typedMixins[i] = mixins[i].substitute2(typeArguments, parameterTypes);
     }
     return typedMixins;
   }
 
   PropertyAccessorElement getSetter(String setterName) => PropertyAccessorMember.from((element as ClassElementImpl).getSetter(setterName), this);
 
   InterfaceType get superclass {
     ClassElement classElement = element;
     InterfaceType supertype = classElement.supertype;
     if (supertype == null) {
       return null;
     }
-    return supertype.substitute2(_typeArguments, classElement.type.typeArguments);
+    return supertype.substitute2(typeArguments, classElement.type.typeArguments);
   }
 
-  List<Type2> get typeArguments => _typeArguments;
-
   List<TypeParameterElement> get typeParameters => element.typeParameters;
 
   int get hashCode {
     ClassElement element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
 
@@ skipping 150 matching lines @@
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
       supertype = supertype.superclass;
       supertypeElement = supertype == null ? null : supertype.element;
     }
     return null;
   }
 
-  /**
-   * Set the actual types of the type arguments to those in the given array.
-   *
-   * @param typeArguments the actual types of the type arguments
-   */
-  void set typeArguments(List<Type2> typeArguments) {
-    this._typeArguments = typeArguments;
-  }
-
   InterfaceTypeImpl substitute4(List<Type2> argumentTypes) => substitute2(argumentTypes, typeArguments);
 
   InterfaceTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException("argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
-    if (argumentTypes.length == 0 || _typeArguments.length == 0) {
+    if (argumentTypes.length == 0 || typeArguments.length == 0) {
       return this;
     }
-    List<Type2> newTypeArguments = TypeImpl.substitute(_typeArguments, argumentTypes, parameterTypes);
-    if (JavaArrays.equals(newTypeArguments, _typeArguments)) {
+    List<Type2> newTypeArguments = TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
+    if (JavaArrays.equals(newTypeArguments, typeArguments)) {
       return this;
     }
     InterfaceTypeImpl newType = new InterfaceTypeImpl.con1(element);
     newType.typeArguments = newTypeArguments;
     return newType;
   }
 
   void appendTo(JavaStringBuilder builder) {
     builder.append(name);
-    int argumentCount = _typeArguments.length;
+    int argumentCount = typeArguments.length;
     if (argumentCount > 0) {
       builder.append("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
-        (_typeArguments[i] as TypeImpl).appendTo(builder);
+        (typeArguments[i] as TypeImpl).appendTo(builder);
       }
       builder.append(">");
     }
   }
 
   bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
@@ skipping 140 matching lines @@
 
   /**
    * The element representing the declaration of this type, or `null` if the type has not, or
    * cannot, be associated with an element.
    */
   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<Type2> EMPTY_ARRAY = new List<Type2>(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) {
+  TypeImpl(Element element, this.name) {
     this._element = element;
-    this._name = name;
   }
 
   String get displayName => name;
 
   Element get element => _element;
 
   Type2 getLeastUpperBound(Type2 type) => null;
 
-  String get name => _name;
-
   bool isAssignableTo(Type2 type) => isAssignableTo2(type, new Set<TypeImpl_TypePair>());
 
   /**
    * Return `true` if this type is assignable to the given type. A type <i>T</i> may be
    * assigned to a type <i>S</i>, written <i>T</i> &hArr; <i>S</i>, iff either <i>T</i> <: <i>S</i>
    * or <i>S</i> <: <i>T</i>.
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
@@ skipping 68 matching lines @@
     appendTo(builder);
     return builder.toString();
   }
 
   /**
    * Append a textual representation of this type to the given builder.
    *
    * @param builder the builder to which the text is to be appended
    */
   void appendTo(JavaStringBuilder builder) {
-    if (_name == null) {
+    if (name == null) {
       builder.append("<unnamed type>");
     } else {
-      builder.append(_name);
+      builder.append(name);
     }
   }
 
   bool internalIsMoreSpecificThan(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs);
 
   bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs);
 }
 
 class TypeImpl_TypePair {
   Type2 _firstType;
@@ skipping 125 matching lines @@
 
 /**
  * The unique instance of the class `VoidTypeImpl` implements the type `void`.
  *
  * @coverage dart.engine.type
  */
 class VoidTypeImpl extends TypeImpl implements VoidType {
   /**
    * The unique instance of this class.
    */
-  static final VoidTypeImpl instance = new VoidTypeImpl();
+  static VoidTypeImpl _INSTANCE = new VoidTypeImpl();
+
+  /**
+   * Return the unique instance of this class.
+   *
+   * @return the unique instance of this class
+   */
+  static VoidTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   VoidTypeImpl() : super(null, Keyword.VOID.syntax);
 
   bool operator ==(Object object) => identical(object, this);
 
   bool get isVoid => true;
 
@@ skipping 613 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);
 }