New Analysis Engine translation.

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 'source.dart';
 import 'scanner.dart' show Keyword;
@@ skipping 465 matching lines @@
    * Return an array containing all of the parameters defined by this executable element.
    * @return the parameters defined by this executable element
    */
   List<ParameterElement> get parameters;
   /**
    * Return the type of function defined by this executable element.
    * @return the type of function defined by this executable element
    */
   FunctionType get type;
   /**
+   * Return {@code true} if this executable element is an operator. The test may be based on the
+   * name of the executable element, in which case the result will be correct when the name is
+   * legal.
+   * @return {@code true} if this executable element is an operator
+   */
+  bool isOperator();
+  /**
    * Return {@code true} if this element is a static element. A static element is an element that is
    * not associated with a particular instance, but rather with an entire library or class.
    * @return {@code true} if this executable element is a static element
    */
   bool isStatic();
 }
 /**
  * The interface {@code ExportElement} defines the behavior of objects representing information
  * about a single export directive within a library.
  * @coverage dart.engine.element
@@ skipping 258 matching lines @@
    * Return the type in which this method is defined.
    * @return the type in which this method is defined
    */
   ClassElement get enclosingElement;
   /**
    * Return {@code true} if this method is abstract. Methods are abstract if they are not external
    * and have no body.
    * @return {@code true} if this method is abstract
    */
   bool isAbstract();
-  /**
-   * Return {@code true} if this method is an operator. The test may be based on the name of the
-   * method, in which case the result will be correct when the name is legal.
-   * @return {@code true} if this method is an operator
-   */
-  bool isOperator();
 }
 /**
  * The interface {@code MultiplyDefinedElement} defines the behavior of pseudo-elements that
  * represent multiple elements defined within a single scope that have the same name. 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 MultiplyDefinedElement implements Element {
@@ skipping 888 matching lines @@
     for (ClassElement type in _types) {
       if (((type as ClassElementImpl)).identifier == identifier26) {
         return type as ClassElementImpl;
       }
     }
     return null;
   }
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
   List<FunctionElement> get functions => _functions;
   List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
-  String get identifier => source.fullName;
+  String get identifier => source.encoding;
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
   Source get source => _source;
   List<TopLevelVariableElement> get topLevelVariables => _variables;
   List<ClassElement> get types => _types;
   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
    */
@@ skipping 10 matching lines @@
   void set functions(List<FunctionElement> functions2) {
     for (FunctionElement function in functions2) {
       ((function as FunctionElementImpl)).enclosingElement = this;
     }
     this._functions = functions2;
   }
   /**
    * 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 source7) {
-    this._source = source7;
+  void set source(Source source5) {
+    this._source = source5;
   }
   /**
    * 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> variables2) {
     for (TopLevelVariableElement field in variables2) {
       ((field as TopLevelVariableElementImpl)).enclosingElement = this;
     }
     this._variables = variables2;
@@ skipping 223 matching lines @@
   Set<Modifier> _modifiers;
   /**
    * An array containing all of the metadata associated with this element.
    */
   List<Annotation> _metadata = AnnotationImpl.EMPTY_ARRAY;
   /**
    * Initialize a newly created element to have the given name.
    * @param name the name of this element
    */
   ElementImpl.con1(Identifier name25) {
-    _jtd_constructor_174_impl(name25);
+    _jtd_constructor_178_impl(name25);
   }
-  _jtd_constructor_174_impl(Identifier name25) {
-    _jtd_constructor_175_impl(name25 == null ? "" : name25.name, name25 == null ? -1 : name25.offset);
+  _jtd_constructor_178_impl(Identifier name25) {
+    _jtd_constructor_179_impl(name25 == null ? "" : name25.name, name25 == null ? -1 : name25.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 name8, int nameOffset2) {
-    _jtd_constructor_175_impl(name8, nameOffset2);
+    _jtd_constructor_179_impl(name8, nameOffset2);
   }
-  _jtd_constructor_175_impl(String name8, int nameOffset2) {
+  _jtd_constructor_179_impl(String name8, int nameOffset2) {
     this._name = name8;
     this._nameOffset = nameOffset2;
     this._modifiers = new Set();
   }
   bool operator ==(Object object) => object != null && identical(object.runtimeType, runtimeType) && ((object as Element)).location == location;
   Element getAncestor(Type elementClass) {
     Element ancestor = _enclosingElement;
     while (ancestor != null && !isInstanceOf(ancestor, elementClass)) {
       ancestor = ancestor.enclosingElement;
     }
@@ skipping 28 matching lines @@
     if (Identifier.isPrivateName(_name)) {
       return library21 == library;
     }
     return true;
   }
   bool 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<Annotation> metadata2) {
-    this._metadata = metadata2;
+  void set metadata(List<Annotation> metadata3) {
+    this._metadata = metadata3;
   }
   /**
    * 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 nameOffset3) {
     this._nameOffset = nameOffset3;
   }
@@ skipping 90 matching lines @@
   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) {
-    _jtd_constructor_176_impl(element);
+    _jtd_constructor_180_impl(element);
   }
-  _jtd_constructor_176_impl(Element element) {
+  _jtd_constructor_180_impl(Element element) {
     List<String> components = new List<String>();
     Element ancestor = element;
     while (ancestor != null) {
       components.insertRange(0, 1, ((ancestor as ElementImpl)).identifier);
       ancestor = ancestor.enclosingElement;
     }
     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) {
-    _jtd_constructor_177_impl(encoding);
+    _jtd_constructor_181_impl(encoding);
   }
-  _jtd_constructor_177_impl(String encoding) {
+  _jtd_constructor_181_impl(String encoding) {
     this._components = decode(encoding);
   }
   bool operator ==(Object object) {
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
     return JavaArrays.equals(_components, location._components);
   }
   /**
@@ skipping 118 matching lines @@
   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
    */
   ExecutableElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_179_impl(name);
+    _jtd_constructor_183_impl(name);
   }
-  _jtd_constructor_179_impl(Identifier name) {
+  _jtd_constructor_183_impl(Identifier name) {
   }
   /**
    * Initialize a newly created executable element to have the given name.
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    * declaration of this element
    */
   ExecutableElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
-    _jtd_constructor_180_impl(name, nameOffset);
+    _jtd_constructor_184_impl(name, nameOffset);
   }
-  _jtd_constructor_180_impl(String name, int nameOffset) {
+  _jtd_constructor_184_impl(String name, int nameOffset) {
   }
   ElementImpl getChild(String identifier27) {
     for (ExecutableElement function in _functions) {
       if (((function as ExecutableElementImpl)).identifier == identifier27) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
       if (((label as LabelElementImpl)).identifier == identifier27) {
         return label as LabelElementImpl;
       }
     }
     for (VariableElement variable in _localVariables) {
       if (((variable as VariableElementImpl)).identifier == identifier27) {
         return variable as VariableElementImpl;
       }
     }
     for (ParameterElement parameter in _parameters) {
       if (((parameter as ParameterElementImpl)).identifier == identifier27) {
         return parameter as ParameterElementImpl;
       }
     }
     return null;
   }
   List<FunctionElement> get functions => _functions;
   List<LabelElement> get labels => _labels;
   List<LocalVariableElement> get localVariables => _localVariables;
   List<ParameterElement> get parameters => _parameters;
   FunctionType get type => _type;
+  bool 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> functions3) {
     for (FunctionElement function in functions3) {
       ((function as FunctionElementImpl)).enclosingElement = this;
     }
     this._functions = functions3;
   }
@@ skipping 134 matching lines @@
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
   /**
    * An empty array of field elements.
    */
   static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);
   /**
    * Initialize a newly created field element to have the given name.
    * @param name the name of this element
    */
   FieldElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_183_impl(name);
+    _jtd_constructor_187_impl(name);
   }
-  _jtd_constructor_183_impl(Identifier name) {
+  _jtd_constructor_187_impl(Identifier name) {
   }
   /**
    * Initialize a newly created synthetic field element to have the given name.
    * @param name the name of this element
    */
   FieldElementImpl.con2(String name) : super.con2(name) {
-    _jtd_constructor_184_impl(name);
+    _jtd_constructor_188_impl(name);
   }
-  _jtd_constructor_184_impl(String name) {
+  _jtd_constructor_188_impl(String name) {
   }
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.FIELD;
   bool isStatic() => hasModifier(Modifier.STATIC);
   /**
    * Set whether this field is static to correspond to the given value.
    * @param isStatic {@code true} if the field is static
    */
   void set static(bool isStatic) {
@@ skipping 15 matching lines @@
    */
   int _visibleRangeLength = -1;
   /**
    * An empty array of function elements.
    */
   static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>(0);
   /**
    * Initialize a newly created synthetic function element.
    */
   FunctionElementImpl() : super.con2("", -1) {
-    _jtd_constructor_185_impl();
+    _jtd_constructor_189_impl();
   }
-  _jtd_constructor_185_impl() {
+  _jtd_constructor_189_impl() {
     synthetic = true;
   }
   /**
    * Initialize a newly created function element to have the given name.
    * @param name the name of this element
    */
   FunctionElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_186_impl(name);
+    _jtd_constructor_190_impl(name);
   }
-  _jtd_constructor_186_impl(Identifier name) {
+  _jtd_constructor_190_impl(Identifier name) {
   }
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
   String get identifier => name;
   ElementKind get kind => ElementKind.FUNCTION;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
@@ skipping 206 matching lines @@
   void set scripts(List<HtmlScriptElement> scripts2) {
     for (HtmlScriptElement script in scripts2) {
       ((script as HtmlScriptElementImpl)).enclosingElement = this;
     }
     this._scripts = scripts2;
   }
   /**
    * 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 source8) {
-    this._source = source8;
+  void set source(Source source6) {
+    this._source = source6;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
       builder.append("{HTML file}");
     } else {
       builder.append(_source.fullName);
@@ skipping 202 matching lines @@
     }
     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;
-      javaSetAdd(libraries, library);
+      if (library != null) {
+        javaSetAdd(libraries, library);
+      }
     }
     return new List.from(libraries);
   }
   List<ExportElement> get exports => _exports;
-  String get identifier => _definingCompilationUnit.source.fullName;
+  String get identifier => _definingCompilationUnit.source.encoding;
   List<LibraryElement> get importedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ImportElement element in _imports) {
-      LibraryElement prefix = element.importedLibrary;
-      javaSetAdd(libraries, prefix);
+      LibraryElement library = element.importedLibrary;
+      if (library != null) {
+        javaSetAdd(libraries, library);
+      }
     }
     return new List.from(libraries);
   }
   List<ImportElement> get imports => _imports;
   ElementKind get kind => ElementKind.LIBRARY;
   List<CompilationUnitElement> get parts => _parts;
   List<PrefixElement> get prefixes {
     Set<PrefixElement> prefixes = new Set<PrefixElement>();
     for (ImportElement element in _imports) {
       PrefixElement prefix4 = element.prefix;
       if (prefix4 != null) {
         javaSetAdd(prefixes, prefix4);
       }
     }
     return new List.from(prefixes);
   }
+  Source get source {
+    if (_definingCompilationUnit == null) {
+      return null;
+    }
+    return _definingCompilationUnit.source;
+  }
   int get hashCode => _definingCompilationUnit.hashCode;
   bool isBrowserApplication() => _entryPoint != null && isOrImportsBrowserLibrary();
   bool isDartCore() => name == "dart.core";
   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 53 matching lines @@
   /**
    * Answer {@code true} if the receiver directly or indirectly imports the dart:html libraries.
    * @return {@code true} if the receiver directly or indirectly imports the dart:html libraries
    */
   bool isOrImportsBrowserLibrary() {
     List<LibraryElement> visited = new List<LibraryElement>();
     Source htmlLibSource = definingCompilationUnit.source.resolve("dart:html");
     visited.add(this);
     for (int index = 0; index < visited.length; index++) {
       LibraryElement library = visited[index];
-      Source source12 = library.definingCompilationUnit.source;
-      if (source12 == htmlLibSource) {
+      Source source10 = library.definingCompilationUnit.source;
+      if (source10 == htmlLibSource) {
         return true;
       }
       for (LibraryElement importedLibrary in library.importedLibraries) {
         if (!visited.contains(importedLibrary)) {
           visited.add(importedLibrary);
         }
       }
       for (LibraryElement exportedLibrary in library.exportedLibraries) {
         if (!visited.contains(exportedLibrary)) {
           visited.add(exportedLibrary);
@@ skipping 59 matching lines @@
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty array of method elements.
    */
   static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
   /**
    * Initialize a newly created method element to have the given name.
    * @param name the name of this element
    */
   MethodElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_195_impl(name);
+    _jtd_constructor_199_impl(name);
   }
-  _jtd_constructor_195_impl(Identifier name) {
+  _jtd_constructor_199_impl(Identifier name) {
   }
   /**
    * Initialize a newly created method element to have the given name.
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    * declaration of this element
    */
   MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
-    _jtd_constructor_196_impl(name, nameOffset);
+    _jtd_constructor_200_impl(name, nameOffset);
   }
-  _jtd_constructor_196_impl(String name, int nameOffset) {
+  _jtd_constructor_200_impl(String name, int nameOffset) {
   }
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.METHOD;
   bool isAbstract() => hasModifier(Modifier.ABSTRACT);
   bool isOperator() {
     String name14 = name;
     if (name14.isEmpty) {
       return false;
     }
@@ skipping 262 matching lines @@
   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) {
-    _jtd_constructor_201_impl(name);
+    _jtd_constructor_205_impl(name);
   }
-  _jtd_constructor_201_impl(Identifier name) {
+  _jtd_constructor_205_impl(Identifier 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 variable2) : super.con2(variable2.name, -1) {
-    _jtd_constructor_202_impl(variable2);
+    _jtd_constructor_206_impl(variable2);
   }
-  _jtd_constructor_202_impl(PropertyInducingElementImpl variable2) {
+  _jtd_constructor_206_impl(PropertyInducingElementImpl variable2) {
     this._variable = variable2;
     synthetic = true;
   }
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
   bool operator ==(Object object) => super == object && identical(isGetter(), ((object as PropertyAccessorElement)).isGetter());
   ElementKind get kind {
     if (isGetter()) {
       return ElementKind.GETTER;
     }
     return ElementKind.SETTER;
@@ skipping 44 matching lines @@
   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) {
-    _jtd_constructor_203_impl(name);
+    _jtd_constructor_207_impl(name);
   }
-  _jtd_constructor_203_impl(Identifier name) {
+  _jtd_constructor_207_impl(Identifier 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) {
-    _jtd_constructor_204_impl(name);
+    _jtd_constructor_208_impl(name);
   }
-  _jtd_constructor_204_impl(String name) {
+  _jtd_constructor_208_impl(String name) {
     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 getter2) {
     this._getter = getter2;
@@ skipping 50 matching lines @@
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements TopLevelVariableElement {
   /**
    * An empty array of top-level variable elements.
    */
   static List<TopLevelVariableElement> EMPTY_ARRAY = new List<TopLevelVariableElement>(0);
   /**
    * Initialize a newly created top-level variable element to have the given name.
    * @param name the name of this element
    */
   TopLevelVariableElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_206_impl(name);
+    _jtd_constructor_210_impl(name);
   }
-  _jtd_constructor_206_impl(Identifier name) {
+  _jtd_constructor_210_impl(Identifier name) {
   }
   /**
    * 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) {
-    _jtd_constructor_207_impl(name);
+    _jtd_constructor_211_impl(name);
   }
-  _jtd_constructor_207_impl(String name) {
+  _jtd_constructor_211_impl(String name) {
   }
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
   bool isStatic() => true;
 }
 /**
  * Instances of the class {@code TypeVariableElementImpl} implement a {@code TypeVariableElement}.
  * @coverage dart.engine.element
  */
 class TypeVariableElementImpl extends ElementImpl implements TypeVariableElement {
@@ skipping 58 matching lines @@
   FunctionElement _initializer;
   /**
    * An empty array of variable elements.
    */
   static List<VariableElement> EMPTY_ARRAY = new List<VariableElement>(0);
   /**
    * Initialize a newly created variable element to have the given name.
    * @param name the name of this element
    */
   VariableElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_209_impl(name);
+    _jtd_constructor_213_impl(name);
   }
-  _jtd_constructor_209_impl(Identifier name) {
+  _jtd_constructor_213_impl(Identifier name) {
   }
   /**
    * Initialize a newly created variable element to have the given name.
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    * declaration of this element
    */
   VariableElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
-    _jtd_constructor_210_impl(name, nameOffset);
+    _jtd_constructor_214_impl(name, nameOffset);
   }
-  _jtd_constructor_210_impl(String name, int nameOffset) {
+  _jtd_constructor_214_impl(String name, int nameOffset) {
   }
   /**
    * Return the result of evaluating this variable's initializer as a compile-time constant
    * expression, or {@code 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;
@@ skipping 172 matching lines @@
   /**
    * The type of object returned by this type of function.
    */
   Type2 _returnType = VoidTypeImpl.instance;
   /**
    * 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) {
-    _jtd_constructor_261_impl(element);
+    _jtd_constructor_265_impl(element);
   }
-  _jtd_constructor_261_impl(ExecutableElement element) {
+  _jtd_constructor_265_impl(ExecutableElement element) {
   }
   /**
    * 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.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name) {
-    _jtd_constructor_262_impl(element);
+    _jtd_constructor_266_impl(element);
   }
-  _jtd_constructor_262_impl(FunctionTypeAliasElement element) {
+  _jtd_constructor_266_impl(FunctionTypeAliasElement element) {
   }
   bool operator ==(Object object) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     return element == otherType.element && JavaArrays.equals(_normalParameterTypes, otherType._normalParameterTypes) && JavaArrays.equals(_optionalParameterTypes, otherType._optionalParameterTypes) && equals2(_namedParameterTypes, otherType._namedParameterTypes);
   }
   Map<String, Type2> get namedParameterTypes => _namedParameterTypes;
   List<Type2> get normalParameterTypes => _normalParameterTypes;
   List<Type2> get optionalParameterTypes => _optionalParameterTypes;
   Type2 get returnType => _returnType;
   List<Type2> get typeArguments => _typeArguments;
   int get hashCode {
-    Element element40 = element;
-    if (element40 == null) {
+    Element element44 = element;
+    if (element44 == null) {
       return 0;
     }
-    return element40.hashCode;
+    return element44.hashCode;
   }
   bool isSubtypeOf(Type2 type) {
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic() || type.isDartCoreFunction()) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
@@ skipping 90 matching lines @@
     this._typeArguments = typeArguments4;
   }
   FunctionTypeImpl substitute4(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 element41 = element;
-    FunctionTypeImpl newType = (element41 is ExecutableElement) ? new FunctionTypeImpl.con1((element41 as ExecutableElement)) : new FunctionTypeImpl.con2((element41 as FunctionTypeAliasElement));
+    Element element45 = element;
+    FunctionTypeImpl newType = (element45 is ExecutableElement) ? new FunctionTypeImpl.con1((element45 as ExecutableElement)) : new FunctionTypeImpl.con2((element45 as FunctionTypeAliasElement));
     newType.returnType = _returnType.substitute2(argumentTypes, parameterTypes);
     newType.normalParameterTypes = TypeImpl.substitute(_normalParameterTypes, argumentTypes, parameterTypes);
     newType.optionalParameterTypes = TypeImpl.substitute(_optionalParameterTypes, argumentTypes, parameterTypes);
     newType._namedParameterTypes = substitute3(_namedParameterTypes, argumentTypes, parameterTypes);
     return newType;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("(");
     bool needsComma = false;
     if (_normalParameterTypes.length > 0) {
@@ skipping 112 matching lines @@
   /**
    * Returns the set of all superinterfaces of the passed {@link Type}. This is a recursive method,
    * callers should call the public {@link #computeSuperinterfaceSet(Type)}.
    * @param type the {@link Type} to compute the set of superinterfaces of
    * @param set a {@link HashSet} used recursively by this method
    * @return the {@link Set} of superinterfaces of the passed {@link Type}
    * @see #computeSuperinterfaceSet(Type)
    * @see #getLeastUpperBound(Type)
    */
   static Set<InterfaceType> computeSuperinterfaceSet2(InterfaceType type, Set<InterfaceType> set) {
-    Element element42 = type.element;
-    if (element42 != null && element42 is ClassElement) {
-      ClassElement classElement = element42 as ClassElement;
+    Element element46 = type.element;
+    if (element46 != null && element46 is ClassElement) {
+      ClassElement classElement = element46 as ClassElement;
       List<InterfaceType> superinterfaces = classElement.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
         javaSetAdd(set, superinterface);
         computeSuperinterfaceSet2(superinterface, set);
       }
       InterfaceType supertype4 = classElement.supertype;
       if (supertype4 != null) {
         javaSetAdd(set, supertype4);
         computeSuperinterfaceSet2(supertype4, set);
       }
     }
     return set;
   }
   /**
    * An array containing the actual types of the type arguments.
    */
   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.name) {
-    _jtd_constructor_263_impl(element);
+    _jtd_constructor_267_impl(element);
   }
-  _jtd_constructor_263_impl(ClassElement element) {
+  _jtd_constructor_267_impl(ClassElement element) {
   }
   /**
    * 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) {
-    _jtd_constructor_264_impl(name);
+    _jtd_constructor_268_impl(name);
   }
-  _jtd_constructor_264_impl(String name) {
+  _jtd_constructor_268_impl(String 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);
   }
   ClassElement get element => super.element as ClassElement;
   Type2 getLeastUpperBound(Type2 type) {
@@ skipping 35 matching lines @@
       }
     }
     return null;
   }
   Type2 get superclass {
     ClassElement classElement = element;
     return element.supertype.substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(classElement.typeVariables));
   }
   List<Type2> get typeArguments => _typeArguments;
   int get hashCode {
-    ClassElement element43 = element;
-    if (element43 == null) {
+    ClassElement element47 = element;
+    if (element47 == null) {
       return 0;
     }
-    return element43.hashCode;
+    return element47.hashCode;
   }
   bool isDartCoreFunction() {
-    ClassElement element44 = element;
-    if (element44 == null) {
+    ClassElement element48 = element;
+    if (element48 == null) {
       return false;
     }
-    return element44.name == "Function" && element44.library.isDartCore();
+    return element48.name == "Function" && element48.library.isDartCore();
   }
   bool isDirectSupertypeOf(InterfaceType type) {
     ClassElement i = element;
     ClassElement j = type.element;
     InterfaceType supertype5 = j.supertype;
     if (supertype5 == null) {
       return false;
     }
     ClassElement supertypeElement = supertype5.element;
     if (supertypeElement == i) {
@@ skipping 579 matching lines @@
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }