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 121 matching lines @@
   InterfaceType get supertype;
 
   /**
    * Return the type defined by the class.
    *
    * @return the type defined by the class
    */
   InterfaceType get type;
 
   /**
-   * Return an array containing all of the type variables declared for this class.
+   * Return an array containing all of the type parameters declared for this class.
    *
-   * @return the type variables declared for this class
+   * @return the type parameters declared for this class
    */
-  List<TypeVariableElement> get typeVariables;
+  List<TypeParameterElement> get typeParameters;
 
   /**
    * Return the unnamed constructor declared in this class, or `null` if this class does not
    * declare an unnamed constructor but does declare named constructors. The returned constructor
    * will be synthetic if this class does not declare any constructors, in which case it will
    * represent the default constructor for the class.
    *
    * @return the unnamed constructor defined in this class
    */
   ConstructorElement get unnamedConstructor;
@@ skipping 430 matching lines @@
   static final ElementKind LABEL = new ElementKind('LABEL', 13, "label");
   static final ElementKind LIBRARY = new ElementKind('LIBRARY', 14, "library");
   static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 15, "local variable");
   static final ElementKind METHOD = new ElementKind('METHOD', 16, "method");
   static final ElementKind NAME = new ElementKind('NAME', 17, "<name>");
   static final ElementKind PARAMETER = new ElementKind('PARAMETER', 18, "parameter");
   static final ElementKind PREFIX = new ElementKind('PREFIX', 19, "import prefix");
   static final ElementKind SETTER = new ElementKind('SETTER', 20, "setter");
   static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 21, "top level variable");
   static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 22, "function type alias");
-  static final ElementKind TYPE_VARIABLE = new ElementKind('TYPE_VARIABLE', 23, "type variable");
+  static final ElementKind TYPE_PARAMETER = new ElementKind('TYPE_PARAMETER', 23, "type parameter");
   static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 24, "<universe>");
   static final List<ElementKind> values = [
       CLASS,
       COMPILATION_UNIT,
       CONSTRUCTOR,
       DYNAMIC,
       EMBEDDED_HTML_SCRIPT,
       ERROR,
       EXPORT,
       EXTERNAL_HTML_SCRIPT,
       FIELD,
       FUNCTION,
       GETTER,
       HTML,
       IMPORT,
       LABEL,
       LIBRARY,
       LOCAL_VARIABLE,
       METHOD,
       NAME,
       PARAMETER,
       PREFIX,
       SETTER,
       TOP_LEVEL_VARIABLE,
       FUNCTION_TYPE_ALIAS,
-      TYPE_VARIABLE,
+      TYPE_PARAMETER,
       UNIVERSE];
 
   /**
    * 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) {
@@ skipping 54 matching lines @@
   R visitImportElement(ImportElement element);
   R visitLabelElement(LabelElement element);
   R visitLibraryElement(LibraryElement element);
   R visitLocalVariableElement(LocalVariableElement element);
   R visitMethodElement(MethodElement element);
   R visitMultiplyDefinedElement(MultiplyDefinedElement element);
   R visitParameterElement(ParameterElement element);
   R visitPrefixElement(PrefixElement element);
   R visitPropertyAccessorElement(PropertyAccessorElement element);
   R visitTopLevelVariableElement(TopLevelVariableElement element);
-  R visitTypeVariableElement(TypeVariableElement element);
+  R visitTypeParameterElement(TypeParameterElement element);
 }
 /**
  * The interface `EmbeddedHtmlScriptElement` defines the behavior of elements representing a
  * script tag in an HTML file having content that defines a Dart library.
  *
  * @coverage dart.engine.element
  */
 abstract class EmbeddedHtmlScriptElement implements HtmlScriptElement {
 
   /**
@@ skipping 174 matching lines @@
   Type2 get returnType;
 
   /**
    * Return the type of function defined by this type alias.
    *
    * @return the type of function defined by this type alias
    */
   FunctionType get type;
 
   /**
-   * Return an array containing all of the type variables defined for this type.
+   * Return an array containing all of the type parameters defined for this type.
    *
-   * @return the type variables defined for this type
+   * @return the type parameters defined for this type
    */
-  List<TypeVariableElement> get typeVariables;
+  List<TypeParameterElement> get typeParameters;
 }
 /**
  * The interface `HideElementCombinator` defines the behavior of combinators that cause some
  * of the names in a namespace to be hidden when being imported.
  *
  * @coverage dart.engine.element
  */
 abstract class HideElementCombinator implements NamespaceCombinator {
 
   /**
@@ skipping 168 matching lines @@
   bool get isBrowserApplication;
 
   /**
    * Return `true` if this library is the dart:core library.
    *
    * @return `true` if this library is the dart:core library
    */
   bool get isDartCore;
 
   /**
+   * Return `true` if this library is the dart:core library.
+   *
+   * @return `true` if this library is the dart:core library
+   */
+  bool get isInSdk;
+
+  /**
    * Return `true` if this library is up to date with respect to the given time stamp. If any
    * transitively referenced Source is newer than the time stamp, this method returns false.
    *
    * @param timeStamp the time stamp to compare against
    * @return `true` if this library is up to date with respect to the given time stamp
    */
   bool isUpToDate2(int timeStamp);
 }
 /**
  * The interface `LocalElement` defines the behavior of elements that can be (but are not
@@ skipping 277 matching lines @@
 }
 /**
  * The interface `TopLevelVariableElement` defines the behavior of elements representing a
  * top-level variable.
  *
  * @coverage dart.engine.element
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {
 }
 /**
- * The interface `TypeVariableElement` defines the behavior of elements representing a type
- * variable.
+ * The interface `TypeParameterElement` defines the behavior of elements representing a type
+ * parameter.
  *
  * @coverage dart.engine.element
  */
-abstract class TypeVariableElement implements Element {
+abstract class TypeParameterElement implements Element {
 
   /**
-   * Return the type representing the bound associated with this variable, or `null` if this
-   * variable does not have an explicit bound.
+   * Return the type representing the bound associated with this parameter, or `null` if this
+   * parameter does not have an explicit bound.
    *
-   * @return the type representing the bound associated with this variable
+   * @return the type representing the bound associated with this parameter
    */
   Type2 get bound;
 
   /**
-   * Return the type defined by this type variable.
+   * Return the type defined by this type parameter.
    *
-   * @return the type defined by this type variable
+   * @return the type defined by this type parameter
    */
-  TypeVariableType get type;
+  TypeParameterType get type;
 }
 /**
  * The interface `UndefinedElement` defines the behavior of pseudo-elements that represent
  * names that are undefined. This situation is not allowed by the language, so objects implementing
  * this interface always represent an error. As a result, most of the normal operations on elements
  * do not make sense and will return useless results.
  *
  * @coverage dart.engine.element
  */
 abstract class UndefinedElement implements Element {
@@ skipping 86 matching lines @@
  *      MethodElement
  *      PropertyAccessorElement
  *   ExportElement
  *   HtmlElement
  *   ImportElement
  *   LabelElement
  *   LibraryElement
  *   MultiplyDefinedElement
  *   PrefixElement
  *   TypeAliasElement
- *   TypeVariableElement
+ *   TypeParameterElement
  *   UndefinedElement
  *   VariableElement
  *      PropertyInducingElement
  *         FieldElement
  *         TopLevelVariableElement
  *      LocalElement
  *         LocalVariableElement
  *         ParameterElement
  *            FieldFormalParameterElement
  * </pre>
@@ skipping 37 matching lines @@
     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);
   R visitTopLevelVariableElement(TopLevelVariableElement element) => visitPropertyInducingElement(element);
-  R visitTypeVariableElement(TypeVariableElement element) => visitElement(element);
+  R visitTypeParameterElement(TypeParameterElement element) => visitElement(element);
   R visitVariableElement(VariableElement element) => visitElement(element);
 }
 /**
  * Instances of the class `RecursiveElementVisitor` implement an element visitor that will
  * recursively visit all of the element in an element model. For example, using an instance of this
  * class to visit a [CompilationUnitElement] will also cause all of the types in the
  * compilation unit to be visited.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or must
  * explicitly ask the visited element to visit its children. Failure to do so will cause the
@@ skipping 79 matching lines @@
     return null;
   }
   R visitPropertyAccessorElement(PropertyAccessorElement element) {
     element.visitChildren(this);
     return null;
   }
   R visitTopLevelVariableElement(TopLevelVariableElement element) {
     element.visitChildren(this);
     return null;
   }
-  R visitTypeVariableElement(TypeVariableElement element) {
+  R visitTypeParameterElement(TypeParameterElement element) {
     element.visitChildren(this);
     return null;
   }
 }
 /**
  * Instances of the class `SimpleElementVisitor` implement an element visitor that will do
  * nothing when visiting an element. It is intended to be a superclass for classes that use the
  * visitor pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a
  * whole structure) and that only need to visit a small number of element types.
  *
@@ skipping 14 matching lines @@
   R visitImportElement(ImportElement element) => null;
   R visitLabelElement(LabelElement element) => null;
   R visitLibraryElement(LibraryElement element) => null;
   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;
+  R visitTypeParameterElement(TypeParameterElement 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 {
 
@@ skipping 62 matching lines @@
    * The superclass of the class, or `null` if the class does not have an explicit superclass.
    */
   InterfaceType _supertype;
 
   /**
    * The type defined by the class.
    */
   InterfaceType _type;
 
   /**
-   * An array containing all of the type variables defined for this class.
+   * An array containing all of the type parameters defined for this class.
    */
-  List<TypeVariableElement> _typeVariables = TypeVariableElementImpl.EMPTY_ARRAY;
+  List<TypeParameterElement> _typeParameters = TypeParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * An empty array of type elements.
    */
   static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
 
   /**
    * Initialize a newly created class element to have the given name.
    *
    * @param name the name of this element
@@ skipping 20 matching lines @@
     for (FieldElement field in _fields) {
       if (((field as FieldElementImpl)).identifier == identifier2) {
         return field as FieldElementImpl;
       }
     }
     for (MethodElement method in _methods) {
       if (((method as MethodElementImpl)).identifier == identifier2) {
         return method as MethodElementImpl;
       }
     }
-    for (TypeVariableElement typeVariable in _typeVariables) {
-      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier2) {
-        return typeVariable as TypeVariableElementImpl;
+    for (TypeParameterElement typeParameter in _typeParameters) {
+      if (((typeParameter as TypeParameterElementImpl)).identifier == identifier2) {
+        return typeParameter as TypeParameterElementImpl;
       }
     }
     return null;
   }
   List<ConstructorElement> get constructors => _constructors;
 
   /**
    * Given some name, this returns the [FieldElement] with the matching name, if there is no
    * such field, then `null` is returned.
    *
@@ skipping 44 matching lines @@
     }
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
   InterfaceType get supertype => _supertype;
   InterfaceType get type => _type;
-  List<TypeVariableElement> get typeVariables => _typeVariables;
+  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;
   }
   bool hasNonFinalField() {
@@ skipping 212 matching lines @@
   /**
    * 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 variables defined for this class to the given type variables.
+   * Set the type parameters defined for this class to the given type parameters.
    *
-   * @param typeVariables the type variables defined for this class
+   * @param typeParameters the type parameters defined for this class
    */
-  void set typeVariables(List<TypeVariableElement> typeVariables2) {
-    for (TypeVariableElement typeVariable in typeVariables2) {
-      ((typeVariable as TypeVariableElementImpl)).enclosingElement = this;
+  void set typeParameters(List<TypeParameterElement> typeParameters2) {
+    for (TypeParameterElement typeParameter in typeParameters2) {
+      ((typeParameter as TypeParameterElementImpl)).enclosingElement = this;
     }
-    this._typeVariables = typeVariables2;
+    this._typeParameters = typeParameters2;
   }
 
   /**
    * 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 visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
-    safelyVisitChildren(_typeVariables, visitor);
+    safelyVisitChildren(_typeParameters, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     String name = displayName;
     if (name == null) {
       builder.append("{unnamed class}");
     } else {
       builder.append(name);
     }
-    int variableCount = _typeVariables.length;
+    int variableCount = _typeParameters.length;
     if (variableCount > 0) {
       builder.append("<");
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
-        ((_typeVariables[i] as TypeVariableElementImpl)).appendTo(builder);
+        ((_typeParameters[i] as TypeParameterElementImpl)).appendTo(builder);
       }
       builder.append(">");
     }
   }
   void collectAllSupertypes(List<InterfaceType> supertypes) {
     List<InterfaceType> typesToVisit = new List<InterfaceType>();
     List<ClassElement> visitedClasses = new List<ClassElement>();
     typesToVisit.add(this.type);
     while (!typesToVisit.isEmpty) {
       InterfaceType currentType = typesToVisit.removeAt(0);
@@ skipping 1353 matching lines @@
    * The return type defined by this type alias.
    */
   Type2 _returnType;
 
   /**
    * The type of function defined by this type alias.
    */
   FunctionType _type;
 
   /**
-   * An array containing all of the type variables defined for this type.
+   * An array containing all of the type parameters defined for this type.
    */
-  List<TypeVariableElement> _typeVariables = TypeVariableElementImpl.EMPTY_ARRAY;
+  List<TypeParameterElement> _typeParameters = TypeParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * An empty array of type alias elements.
    */
   static List<FunctionTypeAliasElement> EMPTY_ARRAY = new List<FunctionTypeAliasElement>(0);
 
   /**
    * Initialize a newly created type alias element to have the given name.
    *
    * @param name the name of this element
    */
   FunctionTypeAliasElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitFunctionTypeAliasElement(this);
   ElementImpl getChild(String identifier2) {
     for (VariableElement parameter in _parameters) {
       if (((parameter as VariableElementImpl)).identifier == identifier2) {
         return parameter as VariableElementImpl;
       }
     }
-    for (TypeVariableElement typeVariable in _typeVariables) {
-      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier2) {
-        return typeVariable as TypeVariableElementImpl;
+    for (TypeParameterElement typeParameter in _typeParameters) {
+      if (((typeParameter as TypeParameterElementImpl)).identifier == identifier2) {
+        return typeParameter as TypeParameterElementImpl;
       }
     }
     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<TypeVariableElement> get typeVariables => _typeVariables;
+  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> parameters2) {
     if (parameters2 != null) {
       for (ParameterElement parameter in parameters2) {
         ((parameter as ParameterElementImpl)).enclosingElement = this;
@@ skipping 14 matching lines @@
   /**
    * 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 type2) {
     this._type = type2;
   }
 
   /**
-   * Set the type variables defined for this type to the given variables.
+   * Set the type parameters defined for this type to the given parameters.
    *
-   * @param typeVariables the type variables defined for this type
+   * @param typeParameters the type parameters defined for this type
    */
-  void set typeVariables(List<TypeVariableElement> typeVariables2) {
-    for (TypeVariableElement variable in typeVariables2) {
-      ((variable as TypeVariableElementImpl)).enclosingElement = this;
+  void set typeParameters(List<TypeParameterElement> typeParameters2) {
+    for (TypeParameterElement typeParameter in typeParameters2) {
+      ((typeParameter as TypeParameterElementImpl)).enclosingElement = this;
     }
-    this._typeVariables = typeVariables2;
+    this._typeParameters = typeParameters2;
   }
 
   /**
    * Set the parameters defined by this type alias to the given parameters without becoming the
    * parent of the parameters. This should only be used by the [TypeResolverVisitor] when
    * creating a synthetic type alias.
    *
    * @param parameters the parameters defined by this type alias
    */
   void shareParameters(List<ParameterElement> parameters2) {
     this._parameters = parameters2;
   }
 
   /**
-   * 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.
+   * Set the type parameters defined for this type to the given parameters without becoming the
+   * parent of the parameters. This should only be used by the [TypeResolverVisitor] when
+   * creating a synthetic type alias.
    *
-   * @param typeVariables the type variables defined for this type
+   * @param typeParameters the type parameters defined for this type
    */
-  void shareTypeVariables(List<TypeVariableElement> typeVariables2) {
-    this._typeVariables = typeVariables2;
+  void shareTypeParameters(List<TypeParameterElement> typeParameters2) {
+    this._typeParameters = typeParameters2;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
-    safelyVisitChildren(_typeVariables, visitor);
+    safelyVisitChildren(_typeParameters, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("typedef ");
     builder.append(displayName);
-    int variableCount = _typeVariables.length;
-    if (variableCount > 0) {
+    int typeParameterCount = _typeParameters.length;
+    if (typeParameterCount > 0) {
       builder.append("<");
-      for (int i = 0; i < variableCount; i++) {
+      for (int i = 0; i < typeParameterCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
-        ((_typeVariables[i] as TypeVariableElementImpl)).appendTo(builder);
+        ((_typeParameters[i] as TypeParameterElementImpl)).appendTo(builder);
       }
       builder.append(">");
     }
     builder.append("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       ((_parameters[i] as ParameterElementImpl)).appendTo(builder);
@@ skipping 427 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 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
    */
@@ skipping 274 matching lines @@
    */
   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 firstElement the first element that conflicts
    * @param secondElement the second element that conflicts
    */
-  MultiplyDefinedElementImpl(AnalysisContext context, Element firstElement, Element secondElement) {
+  MultiplyDefinedElementImpl.con1(AnalysisContext context, Element firstElement, Element secondElement) {
+    this._context = context;
     _name = firstElement.name;
     _conflictingElements = computeConflictingElements(firstElement, secondElement);
   }
+
+  /**
+   * 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.con2(AnalysisContext context, List<Element> conflictingElements) {
+    this._context = context;
+    _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;
@@ skipping 27 matching lines @@
   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) {
+  void add(Set<Element> elements, Element element) {
     if (element is MultiplyDefinedElementImpl) {
       for (Element conflictingElement in ((element as MultiplyDefinedElementImpl))._conflictingElements) {
-        elements.add(conflictingElement);
+        javaSetAdd(elements, conflictingElement);
       }
     } else {
-      elements.add(element);
+      javaSetAdd(elements, 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
    */
   List<Element> computeConflictingElements(Element firstElement, Element secondElement) {
-    List<Element> elements = new List<Element>();
+    Set<Element> elements = new Set<Element>();
     add(elements, firstElement);
     add(elements, secondElement);
     return new List.from(elements);
   }
 }
 /**
  * Instances of the class `ParameterElementImpl` implement a `ParameterElement`.
  *
  * @coverage dart.engine.element
  */
@@ skipping 422 matching lines @@
    * Initialize a newly created synthetic top-level variable element to have the given name.
    *
    * @param name the name of this element
    */
   TopLevelVariableElementImpl.con2(String name) : super.con2(name);
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
   bool get isStatic => true;
 }
 /**
- * Instances of the class `TypeVariableElementImpl` implement a `TypeVariableElement`.
+ * Instances of the class `TypeParameterElementImpl` implement a [TypeParameterElement].
  *
  * @coverage dart.engine.element
  */
-class TypeVariableElementImpl extends ElementImpl implements TypeVariableElement {
+class TypeParameterElementImpl extends ElementImpl implements TypeParameterElement {
 
   /**
-   * The type defined by this type variable.
+   * The type defined by this type parameter.
    */
-  TypeVariableType _type;
+  TypeParameterType _type;
 
   /**
-   * The type representing the bound associated with this variable, or `null` if this variable
-   * does not have an explicit bound.
+   * The type representing the bound associated with this parameter, or `null` if this
+   * parameter does not have an explicit bound.
    */
   Type2 _bound;
 
   /**
-   * An empty array of type variable elements.
+   * An empty array of type parameter elements.
    */
-  static List<TypeVariableElement> EMPTY_ARRAY = new List<TypeVariableElement>(0);
+  static List<TypeParameterElement> EMPTY_ARRAY = new List<TypeParameterElement>(0);
 
   /**
-   * Initialize a newly created type variable element to have the given name.
+   * Initialize a newly created type parameter element to have the given name.
    *
    * @param name the name of this element
    */
-  TypeVariableElementImpl(Identifier name) : super.con1(name);
-  accept(ElementVisitor visitor) => visitor.visitTypeVariableElement(this);
+  TypeParameterElementImpl(Identifier name) : super.con1(name);
+  accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
   Type2 get bound => _bound;
-  ElementKind get kind => ElementKind.TYPE_VARIABLE;
-  TypeVariableType get type => _type;
+  ElementKind get kind => ElementKind.TYPE_PARAMETER;
+  TypeParameterType get type => _type;
 
   /**
-   * Set the type representing the bound associated with this variable to the given 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 variable
+   * @param bound the type representing the bound associated with this parameter
    */
   void set bound(Type2 bound2) {
     this._bound = bound2;
   }
 
   /**
-   * Set the type defined by this type variable to the given type
+   * Set the type defined by this type parameter to the given type
    *
-   * @param type the type defined by this type variable
+   * @param type the type defined by this type parameter
    */
-  void set type(TypeVariableType type2) {
+  void set type(TypeParameterType type2) {
     this._type = type2;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(displayName);
     if (_bound != null) {
       builder.append(" extends ");
       builder.append(_bound);
     }
   }
 }
@@ skipping 363 matching lines @@
 
   /**
    * Return the type that results from replacing the type parameters in the given type with the type
    * arguments.
    *
    * @param type the type to be transformed
    * @return the result of transforming the type
    */
   Type2 substituteFor(Type2 type) {
     List<Type2> argumentTypes = _definingType.typeArguments;
-    List<Type2> parameterTypes = TypeVariableTypeImpl.getTypes(_definingType.typeVariables);
+    List<Type2> parameterTypes = TypeParameterTypeImpl.getTypes(_definingType.typeParameters);
     return type.substitute2(argumentTypes, parameterTypes) as Type2;
   }
 
   /**
    * Return the array of types that results from replacing the type parameters in the given types
    * with the type arguments.
    *
    * @param types the types to be transformed
    * @return the result of transforming the types
    */
@@ skipping 88 matching lines @@
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the parameter element that will return the correctly substituted types
    */
   static ParameterElement from(ParameterElement baseParameter, ParameterizedType definingType) {
     if (baseParameter == null || definingType.typeArguments.length == 0) {
       return baseParameter;
     }
     Type2 baseType = baseParameter.type;
     List<Type2> argumentTypes = definingType.typeArguments;
-    List<Type2> parameterTypes = TypeVariableTypeImpl.getTypes(definingType.typeVariables);
+    List<Type2> parameterTypes = TypeParameterTypeImpl.getTypes(definingType.typeParameters);
     Type2 substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
     if (baseType == substitutedType) {
       return baseParameter;
     }
     return new ParameterMember(baseParameter, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
@@ skipping 354 matching lines @@
       name = builder.toString();
     }
     return name;
   }
   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 = TypeVariableTypeImpl.getTypes(typeVariables);
+    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);
       }
     }
     return namedParameterTypes;
   }
   List<Type2> get normalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
-    List<Type2> typeParameters = TypeVariableTypeImpl.getTypes(typeVariables);
+    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));
       }
     }
     return new List.from(types);
   }
   List<Type2> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
-    List<Type2> typeParameters = TypeVariableTypeImpl.getTypes(typeVariables);
+    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));
       }
     }
     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;
-    return baseReturnType.substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables));
+    if (baseReturnType == null) {
+      return DynamicTypeImpl.instance;
+    }
+    return baseReturnType.substitute2(_typeArguments, TypeParameterTypeImpl.getTypes(typeParameters));
   }
   List<Type2> get typeArguments => _typeArguments;
-  List<TypeVariableElement> get typeVariables {
+  List<TypeParameterElement> get typeParameters {
     Element element = this.element;
     if (element is FunctionTypeAliasElement) {
-      return ((element as FunctionTypeAliasElement)).typeVariables;
+      return ((element as FunctionTypeAliasElement)).typeParameters;
     }
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
-      return definingClass.typeVariables;
+      return definingClass.typeParameters;
     }
-    return TypeVariableElementImpl.EMPTY_ARRAY;
+    return TypeParameterElementImpl.EMPTY_ARRAY;
   }
   int get hashCode {
     Element element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
   bool isAssignableTo(Type2 type) => this.isSubtypeOf(type);
   bool isSubtypeOf(Type2 type) {
@@ skipping 411 matching lines @@
       builder.append(">");
       name = builder.toString();
     }
     return name;
   }
   ClassElement get element => super.element as ClassElement;
   PropertyAccessorElement getGetter(String getterName) => PropertyAccessorMember.from(((element as ClassElementImpl)).getGetter(getterName), this);
   List<InterfaceType> get interfaces {
     ClassElement classElement = element;
     List<InterfaceType> interfaces = classElement.interfaces;
-    List<TypeVariableElement> typeVariables = classElement.typeVariables;
+    List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<Type2> parameterTypes = classElement.type.typeArguments;
-    if (typeVariables.length == 0) {
+    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);
     }
     return typedInterfaces;
   }
   Type2 getLeastUpperBound(Type2 type) {
@@ skipping 42 matching lines @@
     List<MethodElement> methods = element.methods;
     List<MethodElement> members = new List<MethodElement>(methods.length);
     for (int i = 0; i < methods.length; i++) {
       members[i] = MethodMember.from(methods[i], this);
     }
     return members;
   }
   List<InterfaceType> get mixins {
     ClassElement classElement = element;
     List<InterfaceType> mixins = classElement.mixins;
-    List<TypeVariableElement> typeVariables = classElement.typeVariables;
+    List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<Type2> parameterTypes = classElement.type.typeArguments;
-    if (typeVariables.length == 0) {
+    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);
     }
     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);
   }
   List<Type2> get typeArguments => _typeArguments;
-  List<TypeVariableElement> get typeVariables => element.typeVariables;
+  List<TypeParameterElement> get typeParameters => element.typeParameters;
   int get hashCode {
     ClassElement element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
   bool get isDartCoreFunction {
     ClassElement element = this.element;
     if (element == null) {
@@ skipping 29 matching lines @@
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
     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) {
+    } else if (type2 is TypeParameterType) {
       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;
@@ skipping 322 matching lines @@
    */
   void appendTo(JavaStringBuilder builder) {
     if (_name == null) {
       builder.append("<unnamed type>");
     } else {
       builder.append(_name);
     }
   }
 }
 /**
- * Instances of the class `TypeVariableTypeImpl` defines the behavior of objects representing
- * the type introduced by a type variable.
+ * Instances of the class `TypeParameterTypeImpl` defines the behavior of objects representing
+ * the type introduced by a type parameter.
  *
  * @coverage dart.engine.type
  */
-class TypeVariableTypeImpl extends TypeImpl implements TypeVariableType {
+class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
 
   /**
-   * An empty array of type variable types.
+   * An empty array of type parameter types.
    */
-  static List<TypeVariableType> EMPTY_ARRAY = new List<TypeVariableType>(0);
+  static List<TypeParameterType> EMPTY_ARRAY = new List<TypeParameterType>(0);
 
   /**
-   * Return an array containing the type variable types defined by the given array of type variable
-   * elements.
+   * Return an array containing the type parameter types defined by the given array of type
+   * parameter elements.
    *
-   * @param typeVariables the type variable elements defining the type variable types to be returned
-   * @return the type variable types defined by the type variable elements
+   * @param typeParameters the type parameter elements defining the type parameter types to be
+   *          returned
+   * @return the type parameter types defined by the type parameter elements
    */
-  static List<TypeVariableType> getTypes(List<TypeVariableElement> typeVariables) {
-    int count = typeVariables.length;
+  static List<TypeParameterType> getTypes(List<TypeParameterElement> typeParameters) {
+    int count = typeParameters.length;
     if (count == 0) {
       return EMPTY_ARRAY;
     }
-    List<TypeVariableType> types = new List<TypeVariableType>(count);
+    List<TypeParameterType> types = new List<TypeParameterType>(count);
     for (int i = 0; i < count; i++) {
-      types[i] = typeVariables[i].type;
+      types[i] = typeParameters[i].type;
     }
     return types;
   }
 
   /**
-   * Initialize a newly created type variable to be declared by the given element and to have the
-   * given name.
+   * Initialize a newly created type parameter type to be declared by the given element and to have
+   * the given name.
    *
-   * @param element the element representing the declaration of the type variable
+   * @param element the element representing the declaration of the type parameter
    */
-  TypeVariableTypeImpl(TypeVariableElement element) : super(element, element.name);
-  bool operator ==(Object object) => object is TypeVariableTypeImpl && element == ((object as TypeVariableTypeImpl)).element;
-  TypeVariableElement get element => super.element as TypeVariableElement;
+  TypeParameterTypeImpl(TypeParameterElement element) : super(element, element.name);
+  bool operator ==(Object object) => object is TypeParameterTypeImpl && element == ((object as TypeParameterTypeImpl)).element;
+  TypeParameterElement get element => super.element as TypeParameterElement;
   int get hashCode => element.hashCode;
   bool isMoreSpecificThan(Type2 type) {
     Type2 upperBound = element.bound;
     return type == upperBound;
   }
   bool isSubtypeOf(Type2 type) => true;
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
@@ skipping 277 matching lines @@
 
   /**
    * Return `true` if this type is more specific than the given type. An interface type
    * <i>T</i> is more specific than an interface type <i>S</i>, written <i>T &laquo; S</i>, if one
    * of the following conditions is met:
    *
    * * Reflexivity: <i>T</i> is <i>S</i>.
    * * <i>T</i> is bottom.
    * * <i>S</i> is dynamic.
    * * Direct supertype: <i>S</i> is a direct supertype of <i>T</i>.
-   * * <i>T</i> is a type variable and <i>S</i> is the upper bound of <i>T</i>.
+   * * <i>T</i> is a type parameter and <i>S</i> is the upper bound of <i>T</i>.
    * * Covariance: <i>T</i> is of the form <i>I&lt;T<sub>1</sub>, &hellip;, T<sub>n</sub>&gt;</i>
    * and S</i> is of the form <i>I&lt;S<sub>1</sub>, &hellip;, S<sub>n</sub>&gt;</i> and
    * <i>T<sub>i</sub> &laquo; S<sub>i</sub></i>, <i>1 <= i <= n</i>.
    * * Transitivity: <i>T &laquo; U</i> and <i>U &laquo; S</i>.
    *
    *
    * @param type the type being compared with this type
    * @return `true` if this type is more specific than the given type
    */
   bool isMoreSpecificThan(Type2 type);
@@ skipping 159 matching lines @@
    * Return the type resulting from substituting the given arguments for this type's parameters.
    * This is fully equivalent to `substitute(argumentTypes, getTypeArguments())`.
    *
    * @param argumentTypes the actual type arguments being substituted for the type parameters
    * @return the result of performing the substitution
    */
   InterfaceType substitute4(List<Type2> argumentTypes);
   InterfaceType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }
 /**
- * The interface `ParameterizedType` defines the behavior common to objects representing the
- * type with type parameters, such as class and function type alias.
+ * The interface `ParameterizedType` defines the behavior common to objects representing a
+ * type with type parameters, such as a class or function type alias.
  *
  * @coverage dart.engine.type
  */
 abstract class ParameterizedType implements Type2 {
 
   /**
    * Return an array containing the actual types of the type arguments. If this type's element does
    * not have type parameters, then the array should be empty (although it is possible for type
    * arguments to be erroneously declared). If the element has type parameters and the actual type
    * does not explicitly include argument values, then the type "dynamic" will be automatically
    * provided.
    *
    * @return the actual types of the type arguments
    */
   List<Type2> get typeArguments;
 
   /**
-   * Return an array containing all of the type variables declared for this type.
+   * Return an array containing all of the type parameters declared for this type.
    *
-   * @return the type variables declared for this type
+   * @return the type parameters declared for this type
    */
-  List<TypeVariableElement> get typeVariables;
+  List<TypeParameterElement> get typeParameters;
 }
 /**
  * The interface `Type` defines the behavior of objects representing the declared type of
  * elements in the element model.
  *
  * @coverage dart.engine.type
  */
 abstract class Type2 {
 
   /**
@@ skipping 104 matching lines @@
    * not create a copy of this type if no substitutions were required, but will return this type
    * directly.
    *
    * @param argumentTypes the actual type arguments being substituted for the parameters
    * @param parameterTypes the parameters to be replaced
    * @return the result of performing the substitution
    */
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }
 /**
- * The interface `TypeVariableType` defines the behavior of objects representing the type
- * introduced by a type variable.
+ * The interface `TypeParameterType` defines the behavior of objects representing the type
+ * introduced by a type parameter.
  *
  * @coverage dart.engine.type
  */
-abstract class TypeVariableType implements Type2 {
-  TypeVariableElement get element;
+abstract class TypeParameterType implements Type2 {
+  TypeParameterElement get element;
 }
 /**
  * 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);
 }