java2dart improvements and new analyzer_experimental snapshot.

pkg/analyzer_experimental/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';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
@@ skipping 529 matching lines @@
    * @return `true` if this element is synthetic
    */
   bool get isSynthetic;
 
   /**
    * Use the given visitor to visit all of the children of this element. There is no guarantee of
    * the order in which the children will be visited.
    *
    * @param visitor the visitor that will be used to visit the children of this element
    */
-  void visitChildren(ElementVisitor<Object> visitor);
+  void visitChildren(ElementVisitor visitor);
 }
 /**
  * The interface `ElementAnnotation` defines the behavior of objects representing a single
  * annotation associated with an element.
  *
  * @coverage dart.engine.element
  */
 abstract class ElementAnnotation {
 
   /**
    * Return the element representing the field, variable, or const constructor being used as an
    * annotation.
    *
    * @return the field, variable, or constructor being used as an annotation
    */
   Element get element;
 }
 /**
  * The enumeration `ElementKind` defines the various kinds of elements in the element model.
  *
  * @coverage dart.engine.element
  */
-class ElementKind implements Enum<ElementKind> {
+class ElementKind extends Enum<ElementKind> {
   static final ElementKind CLASS = new ElementKind('CLASS', 0, "class");
   static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 1, "compilation unit");
   static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 2, "constructor");
   static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 3, "<dynamic>");
   static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 4, "embedded html script");
   static final ElementKind ERROR = new ElementKind('ERROR', 5, "<error>");
   static final ElementKind EXPORT = new ElementKind('EXPORT', 6, "export directive");
   static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 7, "external html script");
   static final ElementKind FIELD = new ElementKind('FIELD', 8, "field");
   static final ElementKind FUNCTION = new ElementKind('FUNCTION', 9, "function");
@@ skipping 32 matching lines @@
       METHOD,
       NAME,
       PARAMETER,
       PREFIX,
       SETTER,
       TOP_LEVEL_VARIABLE,
       FUNCTION_TYPE_ALIAS,
       TYPE_VARIABLE,
       UNIVERSE];
 
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
-
   /**
    * Return the kind of the given element, or [ERROR] if the element is `null`. This is
    * a utility method that can reduce the need for null checks in other places.
    *
    * @param element the element whose kind is to be returned
    * @return the kind of the given element
    */
   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;
 
   /**
    * 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(this.name, this.ordinal, String displayName) {
+  ElementKind(String name, int ordinal, String displayName) : super(name, ordinal) {
     this._displayName = displayName;
   }
 
   /**
    * Return the name displayed in the UI for this kind of element.
    *
    * @return the name of this [ElementKind] to display in UI.
    */
   String get displayName => _displayName;
-  int compareTo(ElementKind other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
 }
 /**
  * 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 879 matching lines @@
   R visitFieldFormalParameterElement(FieldFormalParameterElement element) => visitParameterElement(element);
   R visitFunctionElement(FunctionElement element) => visitLocalElement(element);
   R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) => visitElement(element);
   R visitHtmlElement(HtmlElement element) => visitElement(element);
   R visitHtmlScriptElement(HtmlScriptElement element) => visitElement(element);
   R visitImportElement(ImportElement element) => visitElement(element);
   R visitLabelElement(LabelElement element) => visitElement(element);
   R visitLibraryElement(LibraryElement element) => visitElement(element);
   R visitLocalElement(LocalElement element) {
     if (element is LocalVariableElement) {
-      return visitVariableElement((element as LocalVariableElement));
+      return visitVariableElement(element as LocalVariableElement);
     } else if (element is ParameterElement) {
-      return visitVariableElement((element as ParameterElement));
+      return visitVariableElement(element as ParameterElement);
     } else if (element is FunctionElement) {
-      return visitExecutableElement((element as FunctionElement));
+      return visitExecutableElement(element as FunctionElement);
     }
     return null;
   }
   R visitLocalVariableElement(LocalVariableElement element) => visitLocalElement(element);
   R visitMethodElement(MethodElement element) => visitExecutableElement(element);
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) => visitElement(element);
   R visitParameterElement(ParameterElement element) => visitLocalElement(element);
   R visitPrefixElement(PrefixElement element) => visitElement(element);
   R visitPropertyAccessorElement(PropertyAccessorElement element) => visitExecutableElement(element);
   R visitPropertyInducingElement(PropertyInducingElement element) => visitVariableElement(element);
@@ skipping 129 matching lines @@
   R visitLocalVariableElement(LocalVariableElement element) => null;
   R visitMethodElement(MethodElement element) => null;
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) => null;
   R visitParameterElement(ParameterElement element) => null;
   R visitPrefixElement(PrefixElement element) => null;
   R visitPropertyAccessorElement(PropertyAccessorElement element) => null;
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
   R visitTypeVariableElement(TypeVariableElement element) => null;
 }
 /**
+ * For AST nodes that could be in both the getter and setter contexts ([IndexExpression]s and
+ * [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;
+
+  /**
+   * 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;
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Get the propagated element.
+   */
+  ExecutableElement get propagatedElement => _propagatedElement;
+
+  /**
+   * Get the static element.
+   */
+  ExecutableElement get staticElement => _staticElement;
+}
+/**
  * 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;
@@ skipping 390 matching lines @@
   }
 
   /**
    * Set whether this class is a valid mixin to correspond to the given value.
    *
    * @param isValidMixin `true` if this class can be used as a mixin
    */
   void set validMixin(bool isValidMixin) {
     setModifier(Modifier.MIXIN, isValidMixin);
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
     safelyVisitChildren(_typeVariables, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     String name = displayName;
     if (name == null) {
@@ skipping 219 matching lines @@
   }
 
   /**
    * 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 uri2) {
     this._uri = uri2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  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) {
       builder.append("{compilation unit}");
@@ skipping 414 matching lines @@
    * @param isSynthetic `true` if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
   }
 
   /**
    * 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) {
       builder.append("<unnamed ");
@@ skipping 19 matching lines @@
    * @return `true` if this element has the given modifier associated with it
    */
   bool hasModifier(Modifier modifier) => BooleanArray.get(_modifiers, modifier);
 
   /**
    * If the given child is not `null`, use the given visitor to visit it.
    *
    * @param child the child to be visited
    * @param visitor the visitor to be used to visit the child
    */
-  void safelyVisitChild(Element child, ElementVisitor<Object> visitor) {
+  void safelyVisitChild(Element child, ElementVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 
   /**
    * Use the given visitor to visit all of the children in the given array.
    *
    * @param children the children to be visited
    * @param visitor the visitor being used to visit the children
    */
-  void safelyVisitChildren(List<Element> children, ElementVisitor<Object> visitor) {
+  void safelyVisitChildren(List<Element> children, ElementVisitor visitor) {
     if (children != null) {
       for (Element child in children) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Set the enclosing element of this element to the given element.
    *
@@ skipping 219 matching lines @@
 
   /**
    * Set the script library defined by the script tag's content.
    *
    * @param scriptLibrary the library or `null` if none
    */
   void set scriptLibrary(LibraryElementImpl scriptLibrary2) {
     scriptLibrary2.enclosingElement = this;
     this._scriptLibrary = scriptLibrary2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_scriptLibrary, visitor);
   }
 }
 /**
  * The abstract class `ExecutableElementImpl` implements the behavior common to
  * `ExecutableElement`s.
  *
  * @coverage dart.engine.element
  */
 abstract class ExecutableElementImpl extends ElementImpl implements ExecutableElement {
@@ skipping 137 matching lines @@
   }
 
   /**
    * 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 type2) {
     this._type = type2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  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++) {
@@ skipping 374 matching lines @@
   /**
    * Set the type variables defined for this type to the given variables without becoming the parent
    * of the variables. This should only be used by the [TypeResolverVisitor] when creating a
    * synthetic type alias.
    *
    * @param typeVariables the type variables defined for this type
    */
   void shareTypeVariables(List<TypeVariableElement> typeVariables2) {
     this._typeVariables = typeVariables2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeVariables, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("typedef ");
     builder.append(displayName);
     int variableCount = _typeVariables.length;
     if (variableCount > 0) {
       builder.append("<");
@@ skipping 117 matching lines @@
   }
 
   /**
    * 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 source2) {
     this._source = source2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
       builder.append("{HTML file}");
     } else {
       builder.append(_source.fullName);
     }
   }
@@ skipping 87 matching lines @@
   }
 
   /**
    * Set the URI that is specified by this directive.
    *
    * @param uri the URI that is specified by this directive.
    */
   void set uri(String uri2) {
     this._uri = uri2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     ((_importedLibrary as LibraryElementImpl)).appendTo(builder);
   }
   String get identifier => ((_importedLibrary as LibraryElementImpl)).identifier;
 }
 /**
@@ skipping 275 matching lines @@
    *
    * @param parts the compilation units that are included in this library using a `part`
    *          directive
    */
   void set parts(List<CompilationUnitElement> parts2) {
     for (CompilationUnitElement compilationUnit in parts2) {
       ((compilationUnit as CompilationUnitElementImpl)).enclosingElement = this;
     }
     this._parts = parts2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_definingCompilationUnit, visitor);
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
   /**
    * Answer `true` if the receiver directly or indirectly imports the dart:html libraries.
    *
@@ skipping 153 matching lines @@
     builder.append(displayName);
     super.appendTo(builder);
   }
 }
 /**
  * The enumeration `Modifier` defines constants for all of the modifiers defined by the Dart
  * language and for a few additional flags that are useful.
  *
  * @coverage dart.engine.element
  */
-class Modifier implements Enum<Modifier> {
+class Modifier extends Enum<Modifier> {
   static final Modifier ABSTRACT = new Modifier('ABSTRACT', 0);
   static final Modifier CONST = new Modifier('CONST', 1);
   static final Modifier FACTORY = new Modifier('FACTORY', 2);
   static final Modifier FINAL = new Modifier('FINAL', 3);
   static final Modifier GETTER = new Modifier('GETTER', 4);
   static final Modifier MIXIN = new Modifier('MIXIN', 5);
   static final Modifier REFERENCES_SUPER = new Modifier('REFERENCES_SUPER', 6);
   static final Modifier SETTER = new Modifier('SETTER', 7);
   static final Modifier STATIC = new Modifier('STATIC', 8);
   static final Modifier SYNTHETIC = new Modifier('SYNTHETIC', 9);
   static final Modifier TYPEDEF = new Modifier('TYPEDEF', 10);
   static final List<Modifier> values = [
       ABSTRACT,
       CONST,
       FACTORY,
       FINAL,
       GETTER,
       MIXIN,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
-
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
-  Modifier(this.name, this.ordinal);
-  int compareTo(Modifier other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
+  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.
  *
  * @coverage dart.engine.element
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
 
   /**
@@ skipping 52 matching lines @@
     int count = _conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       ((_conflictingElements[i] as ElementImpl)).appendTo(builder);
     }
     builder.append("]");
     return builder.toString();
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
   }
 
   /**
    * 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
    */
   void add(List<Element> elements, Element element) {
@@ skipping 139 matching lines @@
    * length.
    *
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     String left = "";
     String right = "";
     while (true) {
       if (parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
@@ skipping 450 matching lines @@
   }
 
   /**
    * Set the declared type of this variable to the given type.
    *
    * @param type the declared type of this variable
    */
   void set type(Type2 type2) {
     this._type = type2;
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 }
 /**
@@ skipping 104 matching lines @@
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] = ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
   Type2 get returnType => substituteFor(baseElement.returnType);
   FunctionType get type => substituteFor(baseElement.type);
   bool get isOperator => baseElement.isOperator;
   bool get isStatic => baseElement.isStatic;
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(baseElement.functions, visitor);
     safelyVisitChildren(labels, visitor);
     safelyVisitChildren(baseElement.localVariables, visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 /**
  * Instances of the class `FieldMember` represent a field element defined in a parameterized
  * type where the values of the type parameters are known.
@@ skipping 82 matching lines @@
   String get displayName => _baseElement.displayName;
   ElementKind get kind => _baseElement.kind;
   LibraryElement get library => _baseElement.library;
   ElementLocation get location => _baseElement.location;
   List<ElementAnnotation> get metadata => _baseElement.metadata;
   String get name => _baseElement.name;
   int get nameOffset => _baseElement.nameOffset;
   Source get source => _baseElement.source;
   bool isAccessibleIn(LibraryElement library) => _baseElement.isAccessibleIn(library);
   bool get isSynthetic => _baseElement.isSynthetic;
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
   }
 
   /**
    * Return the type in which the element is defined.
    *
    * @return the type in which the element is defined
    */
   ParameterizedType get definingType => _definingType;
 
   /**
    * If the given child is not `null`, use the given visitor to visit it.
    *
    * @param child the child to be visited
    * @param visitor the visitor to be used to visit the child
    */
-  void safelyVisitChild(Element child, ElementVisitor<Object> visitor) {
+  void safelyVisitChild(Element child, ElementVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 
   /**
    * Use the given visitor to visit all of the children in the given array.
    *
    * @param children the children to be visited
    * @param visitor the visitor being used to visit the children
    */
-  void safelyVisitChildren(List<Element> children, ElementVisitor<Object> visitor) {
+  void safelyVisitChildren(List<Element> children, ElementVisitor visitor) {
     if (children != null) {
       for (Element child in children) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Return the type that results from replacing the type parameters in the given type with the type
    * arguments.
@@ skipping 127 matching lines @@
    * @param definingType the type in which the element is defined
    */
   ParameterMember(ParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
   Element getAncestor(Type elementClass) {
     Element element = baseElement.getAncestor(elementClass);
     ParameterizedType definingType = this.definingType;
     if (definingType is InterfaceType) {
       InterfaceType definingInterfaceType = definingType as InterfaceType;
       if (element is ConstructorElement) {
-        return ConstructorMember.from((element as ConstructorElement), definingInterfaceType) as Element;
+        return ConstructorMember.from(element as ConstructorElement, definingInterfaceType) as Element;
       } else if (element is MethodElement) {
-        return MethodMember.from((element as MethodElement), definingInterfaceType) as Element;
+        return MethodMember.from(element as MethodElement, definingInterfaceType) as Element;
       } else if (element is PropertyAccessorElement) {
-        return PropertyAccessorMember.from((element as PropertyAccessorElement), definingInterfaceType) as Element;
+        return PropertyAccessorMember.from(element as PropertyAccessorElement, definingInterfaceType) as Element;
       }
     }
     return element;
   }
   ParameterElement get baseElement => super.baseElement as ParameterElement;
   SourceRange get defaultValueRange => baseElement.defaultValueRange;
   Element get enclosingElement => baseElement.enclosingElement;
   ParameterKind get parameterKind => baseElement.parameterKind;
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
@@ skipping 24 matching lines @@
       break;
     }
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(left);
     builder.append(type);
     builder.append(" ");
     builder.append(baseElement.displayName);
     builder.append(right);
     return builder.toString();
   }
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 /**
  * Instances of the class `PropertyAccessorMember` represent a property accessor element
  * defined in a parameterized type where the values of the type parameters are known.
  */
 class PropertyAccessorMember extends ExecutableMember implements PropertyAccessorElement {
 
@@ skipping 31 matching lines @@
    */
   PropertyAccessorMember(PropertyAccessorElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
   PropertyAccessorElement get baseElement => super.baseElement as PropertyAccessorElement;
   PropertyAccessorElement get correspondingGetter => from(baseElement.correspondingGetter, definingType);
   PropertyAccessorElement get correspondingSetter => from(baseElement.correspondingSetter, definingType);
   Element get enclosingElement => baseElement.enclosingElement;
   PropertyInducingElement get variable {
     PropertyInducingElement variable = baseElement.variable;
     if (variable is FieldElement) {
-      return FieldMember.from(((variable as FieldElement)), definingType);
+      return FieldMember.from(variable as FieldElement, definingType);
     }
     return variable;
   }
   bool get isAbstract => baseElement.isAbstract;
   bool get isGetter => baseElement.isGetter;
   bool get isSetter => baseElement.isSetter;
   String toString() {
     PropertyAccessorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
@@ skipping 38 matching lines @@
    * @param definingType the type in which the element is defined
    */
   VariableMember(VariableElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
   VariableElement get baseElement => super.baseElement as VariableElement;
   FunctionElement get initializer {
     throw new UnsupportedOperationException();
   }
   Type2 get type => substituteFor(baseElement.type);
   bool get isConst => baseElement.isConst;
   bool get isFinal => baseElement.isFinal;
-  void visitChildren(ElementVisitor<Object> visitor) {
+  void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }
 /**
  * The unique instance of the class `BottomTypeImpl` implements the type `bottom`.
  *
  * @coverage dart.engine.type
  */
 class BottomTypeImpl extends TypeImpl {
@@ skipping 359 matching lines @@
   }
   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));
+    FunctionTypeImpl newType = (element is ExecutableElement) ? new FunctionTypeImpl.con1(element as ExecutableElement) : new FunctionTypeImpl.con2(element as FunctionTypeAliasElement);
     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 431 matching lines @@
       }
     }
     return false;
   }
   bool isMoreSpecificThan(Type2 type) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
-    return isMoreSpecificThan2((type as InterfaceType), new Set<ClassElement>());
+    return isMoreSpecificThan2(type as InterfaceType, new Set<ClassElement>());
   }
   bool get isObject => element.supertype == null;
   bool isSubtypeOf(Type2 type2) {
     if (identical(type2, DynamicTypeImpl.instance)) {
       return true;
     } else if (type2 is TypeVariableType) {
       return true;
     } else if (type2 is FunctionType) {
       ClassElement element = this.element;
       MethodElement callMethod = element.lookUpMethod("call", element.library);
       if (callMethod != null) {
         return callMethod.type.isSubtypeOf(type2);
       }
       return false;
     } else if (type2 is! InterfaceType) {
       return false;
     } else if (this == type2) {
       return true;
     }
-    return isSubtypeOf2((type2 as InterfaceType), new Set<ClassElement>());
+    return isSubtypeOf2(type2 as InterfaceType, new Set<ClassElement>());
   }
   ConstructorElement lookUpConstructor(String constructorName, LibraryElement library) {
     ConstructorElement constructorElement;
     if (constructorName == null) {
       constructorElement = element.unnamedConstructor;
     } else {
       constructorElement = element.getNamedConstructor(constructorName);
     }
     if (constructorElement == null || !constructorElement.isAccessibleIn(library)) {
       return null;
@@ skipping 997 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);
 }