Rename analyzer-experimental to analyzer_experimental.

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;
 import 'ast.dart' show Identifier, LibraryIdentifier;
 import 'html.dart' show XmlTagNode;
 import 'engine.dart' show AnalysisContext;
+import 'constant.dart' show EvaluationResultImpl;
 import 'utilities_dart.dart';
 
 /**
  * The interface {@code Annotation} defines the behavior of objects representing a single annotation
  * associated with an element.
  * @coverage dart.engine.element
  */
 abstract class Annotation {
   /**
    * Return the element representing the field, variable, or const constructor being used as an
@@ skipping 177 matching lines @@
    * Return an array containing all of the top-level functions contained in this compilation unit.
    * @return the top-level functions contained in this compilation unit
    */
   List<FunctionElement> get functions;
   /**
    * Return an array containing all of the top-level variables contained in this compilation unit.
    * @return the top-level variables contained in this compilation unit
    */
   List<TopLevelVariableElement> get topLevelVariables;
   /**
-   * Return an array containing all of the type aliases contained in this compilation unit.
-   * @return the type aliases contained in this compilation unit
+   * Return an array containing all of the function type aliases contained in this compilation unit.
+   * @return the function type aliases contained in this compilation unit
    */
-  List<TypeAliasElement> get typeAliases;
+  List<FunctionTypeAliasElement> get functionTypeAliases;
   /**
    * Return an array containing all of the classes contained in this compilation unit.
    * @return the classes contained in this compilation unit
    */
   List<ClassElement> get types;
 }
 /**
  * The interface {@code ConstructorElement} defines the behavior of elements representing a
  * constructor or a factory method defined within a type.
  * @coverage dart.engine.element
@@ skipping 148 matching lines @@
   static final ElementKind IMPORT = new ElementKind('IMPORT', 12, "import directive");
   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 TYPE_ALIAS = new ElementKind('TYPE_ALIAS', 22, "function type alias");
+  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 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, TYPE_ALIAS, TYPE_VARIABLE, 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, UNIVERSE];
   final String __name;
   final int __ordinal;
   int get ordinal => __ordinal;
   String _displayName;
   ElementKind(this.__name, this.__ordinal, String displayName) {
     this._displayName = displayName;
   }
   /**
    * @return the name of this {@link ElementKind} to display in UI.
    */
@@ skipping 31 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 visitTypeAliasElement(TypeAliasElement element);
+  R visitFunctionTypeAliasElement(FunctionTypeAliasElement element);
   R visitTypeVariableElement(TypeVariableElement element);
 }
 /**
  * The interface {@code 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 {
   /**
    * Return the library element defined by the content of the script tag.
@@ skipping 87 matching lines @@
    */
   ClassElement get enclosingElement;
 }
 /**
  * The interface {@code FunctionElement} defines the behavior of elements representing a function.
  * @coverage dart.engine.element
  */
 abstract class FunctionElement implements ExecutableElement, LocalElement {
 }
 /**
+ * The interface {@code FunctionTypeAliasElement} defines the behavior of elements representing a
+ * function type alias ({@code typedef}).
+ * @coverage dart.engine.element
+ */
+abstract class FunctionTypeAliasElement implements Element {
+  /**
+   * Return the compilation unit in which this type alias is defined.
+   * @return the compilation unit in which this type alias is defined
+   */
+  CompilationUnitElement get enclosingElement;
+  /**
+   * Return an array containing all of the parameters defined by this type alias.
+   * @return the parameters defined by this type alias
+   */
+  List<ParameterElement> get parameters;
+  /**
+   * 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 the type variables defined for this type
+   */
+  List<TypeVariableElement> get typeVariables;
+}
+/**
  * The interface {@code HideCombinator} 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 HideCombinator implements NamespaceCombinator {
   /**
    * Return an array containing the names that are not to be made visible in the importing library
    * even if they are defined in the imported library.
    * @return the names from the imported library that are hidden from the importing library
    */
@@ skipping 324 matching lines @@
   List<String> get shownNames;
 }
 /**
  * The interface {@code TopLevelVariableElement} defines the behavior of elements representing a
  * top-level variable.
  * @coverage dart.engine.element
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {
 }
 /**
- * The interface {@code TypeAliasElement} defines the behavior of elements representing a type alias
- * ({@code typedef}).
- * @coverage dart.engine.element
- */
-abstract class TypeAliasElement implements Element {
-  /**
-   * Return the compilation unit in which this type alias is defined.
-   * @return the compilation unit in which this type alias is defined
-   */
-  CompilationUnitElement get enclosingElement;
-  /**
-   * Return an array containing all of the parameters defined by this type alias.
-   * @return the parameters defined by this type alias
-   */
-  List<ParameterElement> get parameters;
-  /**
-   * 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 the type variables defined for this type
-   */
-  List<TypeVariableElement> get typeVariables;
-}
-/**
  * The interface {@code TypeVariableElement} defines the behavior of elements representing a type
  * variable.
  * @coverage dart.engine.element
  */
 abstract class TypeVariableElement implements Element {
   /**
    * Return the type representing the bound associated with this variable, or {@code null} if this
    * variable does not have an explicit bound.
    * @return the type representing the bound associated with this variable
    */
@@ skipping 125 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 visitTypeAliasElement(TypeAliasElement element) => visitElement(element);
+  R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) => visitElement(element);
   R visitTypeVariableElement(TypeVariableElement element) => visitElement(element);
   R visitVariableElement(VariableElement element) => visitElement(element);
 }
 /**
  * Instances of the class {@code 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 {@link CompilationUnitElement} will also cause all of the types in the
  * compilation unit to be visited.
  * <p>
  * Subclasses that override a visit method must either invoke the overridden visit method or must
@@ skipping 71 matching lines @@
     return null;
   }
   R visitPropertyAccessorElement(PropertyAccessorElement element) {
     element.visitChildren(this);
     return null;
   }
   R visitTopLevelVariableElement(TopLevelVariableElement element) {
     element.visitChildren(this);
     return null;
   }
-  R visitTypeAliasElement(TypeAliasElement element) {
+  R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
     element.visitChildren(this);
     return null;
   }
   R visitTypeVariableElement(TypeVariableElement element) {
     element.visitChildren(this);
     return null;
   }
 }
 /**
  * Instances of the class {@code SimpleElementVisitor} implement an element visitor that will do
@@ skipping 15 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 visitTypeAliasElement(TypeAliasElement element) => null;
+  R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) => null;
   R visitTypeVariableElement(TypeVariableElement element) => null;
 }
 /**
  * Instances of the class {@code AnnotationImpl} implement an {@link Annotation}.
  * @coverage dart.engine.element
  */
 class AnnotationImpl implements Annotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
@@ skipping 409 matching lines @@
   List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the variables contained in this compilation unit.
    */
   List<TopLevelVariableElement> _variables = TopLevelVariableElementImpl.EMPTY_ARRAY;
   /**
    * The source that corresponds to this compilation unit.
    */
   Source _source;
   /**
-   * An array containing all of the type aliases contained in this compilation unit.
+   * An array containing all of the function type aliases contained in this compilation unit.
    */
-  List<TypeAliasElement> _typeAliases = TypeAliasElementImpl.EMPTY_ARRAY;
+  List<FunctionTypeAliasElement> _typeAliases = FunctionTypeAliasElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the types contained in this compilation unit.
    */
   List<ClassElement> _types = ClassElementImpl.EMPTY_ARRAY;
   /**
    * An empty array of compilation unit elements.
    */
   static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
   /**
    * Initialize a newly created compilation unit element to have the given name.
    * @param name the name of this element
    */
   CompilationUnitElementImpl(String name) : super.con2(name, -1) {
   }
   accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
-  bool operator ==(Object object) => identical(runtimeType, object.runtimeType) && _source == ((object as CompilationUnitElementImpl)).source;
+  bool operator ==(Object object) => object != null && identical(runtimeType, object.runtimeType) && _source == ((object as CompilationUnitElementImpl)).source;
   List<PropertyAccessorElement> get accessors => _accessors;
   ElementImpl getChild(String identifier26) {
     for (PropertyAccessorElement accessor in _accessors) {
       if (((accessor as PropertyAccessorElementImpl)).identifier == identifier26) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
     for (VariableElement variable in _variables) {
       if (((variable as VariableElementImpl)).identifier == identifier26) {
         return variable as VariableElementImpl;
       }
     }
     for (ExecutableElement function in _functions) {
       if (((function as ExecutableElementImpl)).identifier == identifier26) {
         return function as ExecutableElementImpl;
       }
     }
-    for (TypeAliasElement typeAlias in _typeAliases) {
-      if (((typeAlias as TypeAliasElementImpl)).identifier == identifier26) {
-        return typeAlias as TypeAliasElementImpl;
+    for (FunctionTypeAliasElement typeAlias in _typeAliases) {
+      if (((typeAlias as FunctionTypeAliasElementImpl)).identifier == identifier26) {
+        return typeAlias as FunctionTypeAliasElementImpl;
       }
     }
     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;
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
   Source get source => _source;
   List<TopLevelVariableElement> get topLevelVariables => _variables;
-  List<TypeAliasElement> get typeAliases => _typeAliases;
   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
    */
   void set accessors(List<PropertyAccessorElement> accessors3) {
     for (PropertyAccessorElement accessor in accessors3) {
       ((accessor as PropertyAccessorElementImpl)).enclosingElement = this;
@@ skipping 21 matching lines @@
    * 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;
   }
   /**
-   * Set the type aliases contained in this compilation unit to the given type aliases.
-   * @param typeAliases the type aliases contained in this compilation unit
+   * Set the function type aliases contained in this compilation unit to the given type aliases.
+   * @param typeAliases the function type aliases contained in this compilation unit
    */
-  void set typeAliases(List<TypeAliasElement> typeAliases2) {
-    for (TypeAliasElement typeAlias in typeAliases2) {
-      ((typeAlias as TypeAliasElementImpl)).enclosingElement = this;
+  void set typeAliases(List<FunctionTypeAliasElement> typeAliases2) {
+    for (FunctionTypeAliasElement typeAlias in typeAliases2) {
+      ((typeAlias as FunctionTypeAliasElementImpl)).enclosingElement = this;
     }
     this._typeAliases = typeAliases2;
   }
   /**
    * Set the types contained in this compilation unit to the given types.
    * @param types types contained in this compilation unit
    */
   void set types(List<ClassElement> types2) {
     for (ClassElement type in types2) {
       ((type as ClassElementImpl)).enclosingElement = this;
@@ skipping 10 matching lines @@
   }
   void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
       builder.append("{compilation unit}");
     } else {
       builder.append(_source.fullName);
     }
   }
 }
 /**
+ * Instances of the class {@code ConstFieldElementImpl} implement a {@code FieldElement} for a
+ * 'const' field that has an initializer.
+ */
+class ConstFieldElementImpl extends FieldElementImpl {
+  /**
+   * The result of evaluating this variable's initializer.
+   */
+  EvaluationResultImpl _result;
+  /**
+   * Initialize a newly created field element to have the given name.
+   * @param name the name of this element
+   */
+  ConstFieldElementImpl(Identifier name) : super.con1(name) {
+  }
+  EvaluationResultImpl get evaluationResult => _result;
+  void set evaluationResult(EvaluationResultImpl result2) {
+    this._result = result2;
+  }
+}
+/**
+ * Instances of the class {@code ConstLocalVariableElementImpl} implement a{@code LocalVariableElement} for a local 'const' variable that has an initializer.
+ * @coverage dart.engine.element
+ */
+class ConstLocalVariableElementImpl extends LocalVariableElementImpl {
+  /**
+   * The result of evaluating this variable's initializer.
+   */
+  EvaluationResultImpl _result;
+  /**
+   * Initialize a newly created local variable element to have the given name.
+   * @param name the name of this element
+   */
+  ConstLocalVariableElementImpl(Identifier name) : super(name) {
+  }
+  EvaluationResultImpl get evaluationResult => _result;
+  void set evaluationResult(EvaluationResultImpl result3) {
+    this._result = result3;
+  }
+}
+/**
+ * Instances of the class {@code ConstParameterElementImpl} implement a {@code ParameterElement} for
+ * a 'const' parameter that has an initializer.
+ * @coverage dart.engine.element
+ */
+class ConstParameterElementImpl extends ParameterElementImpl {
+  /**
+   * The result of evaluating this variable's initializer.
+   */
+  EvaluationResultImpl _result;
+  /**
+   * Initialize a newly created parameter element to have the given name.
+   * @param name the name of this element
+   */
+  ConstParameterElementImpl(Identifier name) : super(name) {
+  }
+  EvaluationResultImpl get evaluationResult => _result;
+  void set evaluationResult(EvaluationResultImpl result4) {
+    this._result = result4;
+  }
+}
+/**
+ * Instances of the class {@code ConstTopLevelVariableElementImpl} implement a{@code TopLevelVariableElement} for a top-level 'const' variable that has an initializer.
+ */
+class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl {
+  /**
+   * The result of evaluating this variable's initializer.
+   */
+  EvaluationResultImpl _result;
+  /**
+   * Initialize a newly created top-level variable element to have the given name.
+   * @param name the name of this element
+   */
+  ConstTopLevelVariableElementImpl(Identifier name) : super.con1(name) {
+  }
+  EvaluationResultImpl get evaluationResult => _result;
+  void set evaluationResult(EvaluationResultImpl result5) {
+    this._result = result5;
+  }
+}
+/**
  * Instances of the class {@code ConstructorElementImpl} implement a {@code ConstructorElement}.
  * @coverage dart.engine.element
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
    * An empty array of constructor elements.
    */
   static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>(0);
   /**
    * Initialize a newly created constructor element to have the given name.
    * @param name the name of this element
    */
   ConstructorElementImpl(Identifier name) : super.con1(name) {
   }
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.CONSTRUCTOR;
   bool isConst() => hasModifier(Modifier.CONST);
   bool isFactory() => hasModifier(Modifier.FACTORY);
   bool isStatic() => false;
   /**
+   * Set whether this constructor represents a 'const' constructor to the given value.
+   * @param isConst {@code true} if this constructor represents a 'const' constructor
+   */
+  void set const2(bool isConst) {
+    setModifier(Modifier.CONST, isConst);
+  }
+  /**
    * Set whether this constructor represents a factory method to the given value.
    * @param isFactory {@code true} if this constructor represents a factory method
    */
   void set factory(bool isFactory) {
     setModifier(Modifier.FACTORY, isFactory);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(enclosingElement.name);
     String name12 = name;
     if (name12 != null && !name12.isEmpty) {
@@ skipping 67 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 name24) {
-    _jtd_constructor_161_impl(name24);
+    _jtd_constructor_172_impl(name24);
   }
-  _jtd_constructor_161_impl(Identifier name24) {
-    _jtd_constructor_162_impl(name24 == null ? "" : name24.name, name24 == null ? -1 : name24.offset);
+  _jtd_constructor_172_impl(Identifier name24) {
+    _jtd_constructor_173_impl(name24 == null ? "" : name24.name, name24 == null ? -1 : name24.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_162_impl(name8, nameOffset2);
+    _jtd_constructor_173_impl(name8, nameOffset2);
   }
-  _jtd_constructor_162_impl(String name8, int nameOffset2) {
+  _jtd_constructor_173_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 17 matching lines @@
   List<Annotation> get metadata => _metadata;
   String get name => _name;
   int get nameOffset => _nameOffset;
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
   int get hashCode => location.hashCode;
-  bool isAccessibleIn(LibraryElement library20) {
+  bool isAccessibleIn(LibraryElement library21) {
     if (Identifier.isPrivateName(_name)) {
-      return library20 == library;
+      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;
@@ skipping 91 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_163_impl(element);
+    _jtd_constructor_174_impl(element);
   }
-  _jtd_constructor_163_impl(Element element) {
+  _jtd_constructor_174_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_164_impl(encoding);
+    _jtd_constructor_175_impl(encoding);
   }
-  _jtd_constructor_164_impl(String encoding) {
+  _jtd_constructor_175_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_166_impl(name);
+    _jtd_constructor_177_impl(name);
   }
-  _jtd_constructor_166_impl(Identifier name) {
+  _jtd_constructor_177_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_167_impl(name, nameOffset);
+    _jtd_constructor_178_impl(name, nameOffset);
   }
-  _jtd_constructor_167_impl(String name, int nameOffset) {
+  _jtd_constructor_178_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;
@@ skipping 163 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_170_impl(name);
+    _jtd_constructor_181_impl(name);
   }
-  _jtd_constructor_170_impl(Identifier name) {
+  _jtd_constructor_181_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_171_impl(name);
+    _jtd_constructor_182_impl(name);
   }
-  _jtd_constructor_171_impl(String name) {
+  _jtd_constructor_182_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_172_impl();
+    _jtd_constructor_183_impl();
   }
-  _jtd_constructor_172_impl() {
+  _jtd_constructor_183_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_173_impl(name);
+    _jtd_constructor_184_impl(name);
   }
-  _jtd_constructor_173_impl(Identifier name) {
+  _jtd_constructor_184_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 11 matching lines @@
   }
   void appendTo(JavaStringBuilder builder) {
     String name13 = name;
     if (name13 != null) {
       builder.append(name13);
     }
     super.appendTo(builder);
   }
 }
 /**
+ * Instances of the class {@code FunctionTypeAliasElementImpl} implement a{@code FunctionTypeAliasElement}.
+ * @coverage dart.engine.element
+ */
+class FunctionTypeAliasElementImpl extends ElementImpl implements FunctionTypeAliasElement {
+  /**
+   * An array containing all of the parameters defined by this type alias.
+   */
+  List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
+  /**
+   * The type of function defined by this type alias.
+   */
+  FunctionType _type;
+  /**
+   * An array containing all of the type variables defined for this type.
+   */
+  List<TypeVariableElement> _typeVariables = TypeVariableElementImpl.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 identifier28) {
+    for (VariableElement parameter in _parameters) {
+      if (((parameter as VariableElementImpl)).identifier == identifier28) {
+        return parameter as VariableElementImpl;
+      }
+    }
+    for (TypeVariableElement typeVariable in _typeVariables) {
+      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier28) {
+        return typeVariable as TypeVariableElementImpl;
+      }
+    }
+    return null;
+  }
+  CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
+  ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
+  List<ParameterElement> get parameters => _parameters;
+  FunctionType get type => _type;
+  List<TypeVariableElement> get typeVariables => _typeVariables;
+  /**
+   * 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> parameters8) {
+    if (parameters8 != null) {
+      for (ParameterElement parameter in parameters8) {
+        ((parameter as ParameterElementImpl)).enclosingElement = this;
+      }
+    }
+    this._parameters = parameters8;
+  }
+  /**
+   * 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 type8) {
+    this._type = type8;
+  }
+  /**
+   * Set the type variables defined for this type to the given variables.
+   * @param typeVariables the type variables defined for this type
+   */
+  void set typeVariables(List<TypeVariableElement> typeVariables3) {
+    for (TypeVariableElement variable in typeVariables3) {
+      ((variable as TypeVariableElementImpl)).enclosingElement = this;
+    }
+    this._typeVariables = typeVariables3;
+  }
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChildren(_parameters, visitor);
+    safelyVisitChildren(_typeVariables, visitor);
+  }
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("typedef ");
+    builder.append(name);
+    int variableCount = _typeVariables.length;
+    if (variableCount > 0) {
+      builder.append("<");
+      for (int i = 0; i < variableCount; i++) {
+        if (i > 0) {
+          builder.append(", ");
+        }
+        ((_typeVariables[i] as TypeVariableElementImpl)).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);
+    }
+    builder.append(")");
+    if (_type != null) {
+      builder.append(" -> ");
+      builder.append(_type.returnType);
+    }
+  }
+}
+/**
  * Instances of the class {@code ShowCombinatorImpl} implement a {@link ShowCombinator}.
  * @coverage dart.engine.element
  */
 class HideCombinatorImpl implements HideCombinator {
   /**
    * The names that are not to be made visible in the importing library even if they are defined in
    * the imported library.
    */
   List<String> _hiddenNames = StringUtilities.EMPTY_ARRAY;
   /**
@@ skipping 271 matching lines @@
   List<CompilationUnitElement> _parts = CompilationUnitElementImpl.EMPTY_ARRAY;
   /**
    * Initialize a newly created library element to have the given name.
    * @param context the analysis context in which the library is defined
    * @param name the name of this element
    */
   LibraryElementImpl(AnalysisContext context, LibraryIdentifier name) : super.con1(name) {
     this._context = context;
   }
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
-  bool operator ==(Object object) => identical(runtimeType, object.runtimeType) && _definingCompilationUnit == ((object as LibraryElementImpl)).definingCompilationUnit;
-  ElementImpl getChild(String identifier28) {
-    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier28) {
+  bool operator ==(Object object) => object != null && identical(runtimeType, object.runtimeType) && _definingCompilationUnit == ((object as LibraryElementImpl)).definingCompilationUnit;
+  ElementImpl getChild(String identifier29) {
+    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier29) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
-      if (((part as CompilationUnitElementImpl)).identifier == identifier28) {
+      if (((part as CompilationUnitElementImpl)).identifier == identifier29) {
         return part as CompilationUnitElementImpl;
       }
     }
     return null;
   }
   AnalysisContext get context => _context;
   CompilationUnitElement get definingCompilationUnit => _definingCompilationUnit;
   FunctionElement get entryPoint => _entryPoint;
   List<LibraryElement> get exportedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
@@ skipping 129 matching lines @@
   /**
    * The length of the visible range for this element, or {@code -1} if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
   /**
    * An empty array of field elements.
    */
   static List<LocalVariableElement> EMPTY_ARRAY = new List<LocalVariableElement>(0);
   /**
-   * Initialize a newly created parameter element to have the given name.
+   * Initialize a newly created local variable element to have the given name.
    * @param name the name of this element
    */
   LocalVariableElementImpl(Identifier name) : super.con1(name) {
   }
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
@@ skipping 23 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_181_impl(name);
+    _jtd_constructor_193_impl(name);
   }
-  _jtd_constructor_181_impl(Identifier name) {
+  _jtd_constructor_193_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_182_impl(name, nameOffset);
+    _jtd_constructor_194_impl(name, nameOffset);
   }
-  _jtd_constructor_182_impl(String name, int nameOffset) {
+  _jtd_constructor_194_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 isStatic() => hasModifier(Modifier.STATIC);
   /**
    * Set whether this method is abstract to correspond to the given value.
    * @param isAbstract {@code true} if the method is abstract
    */
@@ skipping 254 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_187_impl(name);
+    _jtd_constructor_199_impl(name);
   }
-  _jtd_constructor_187_impl(Identifier name) {
+  _jtd_constructor_199_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_188_impl(variable2);
+    _jtd_constructor_200_impl(variable2);
   }
-  _jtd_constructor_188_impl(PropertyInducingElementImpl variable2) {
+  _jtd_constructor_200_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_189_impl(name);
+    _jtd_constructor_201_impl(name);
   }
-  _jtd_constructor_189_impl(Identifier name) {
+  _jtd_constructor_201_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_190_impl(name);
+    _jtd_constructor_202_impl(name);
   }
-  _jtd_constructor_190_impl(String name) {
+  _jtd_constructor_202_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_192_impl(name);
+    _jtd_constructor_204_impl(name);
   }
-  _jtd_constructor_192_impl(Identifier name) {
+  _jtd_constructor_204_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_193_impl(name);
+    _jtd_constructor_205_impl(name);
   }
-  _jtd_constructor_193_impl(String name) {
+  _jtd_constructor_205_impl(String name) {
   }
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
   bool isStatic() => true;
 }
 /**
- * Instances of the class {@code TypeAliasElementImpl} implement a {@code TypeAliasElement}.
- * @coverage dart.engine.element
- */
-class TypeAliasElementImpl extends ElementImpl implements TypeAliasElement {
-  /**
-   * An array containing all of the parameters defined by this type alias.
-   */
-  List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
-  /**
-   * The type of function defined by this type alias.
-   */
-  FunctionType _type;
-  /**
-   * An array containing all of the type variables defined for this type.
-   */
-  List<TypeVariableElement> _typeVariables = TypeVariableElementImpl.EMPTY_ARRAY;
-  /**
-   * An empty array of type alias elements.
-   */
-  static List<TypeAliasElement> EMPTY_ARRAY = new List<TypeAliasElement>(0);
-  /**
-   * Initialize a newly created type alias element to have the given name.
-   * @param name the name of this element
-   */
-  TypeAliasElementImpl(Identifier name) : super.con1(name) {
-  }
-  accept(ElementVisitor visitor) => visitor.visitTypeAliasElement(this);
-  ElementImpl getChild(String identifier29) {
-    for (VariableElement parameter in _parameters) {
-      if (((parameter as VariableElementImpl)).identifier == identifier29) {
-        return parameter as VariableElementImpl;
-      }
-    }
-    for (TypeVariableElement typeVariable in _typeVariables) {
-      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier29) {
-        return typeVariable as TypeVariableElementImpl;
-      }
-    }
-    return null;
-  }
-  CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
-  ElementKind get kind => ElementKind.TYPE_ALIAS;
-  List<ParameterElement> get parameters => _parameters;
-  FunctionType get type => _type;
-  List<TypeVariableElement> get typeVariables => _typeVariables;
-  /**
-   * 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> parameters8) {
-    if (parameters8 != null) {
-      for (ParameterElement parameter in parameters8) {
-        ((parameter as ParameterElementImpl)).enclosingElement = this;
-      }
-    }
-    this._parameters = parameters8;
-  }
-  /**
-   * 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 type8) {
-    this._type = type8;
-  }
-  /**
-   * Set the type variables defined for this type to the given variables.
-   * @param typeVariables the type variables defined for this type
-   */
-  void set typeVariables(List<TypeVariableElement> typeVariables3) {
-    for (TypeVariableElement variable in typeVariables3) {
-      ((variable as TypeVariableElementImpl)).enclosingElement = this;
-    }
-    this._typeVariables = typeVariables3;
-  }
-  void visitChildren(ElementVisitor<Object> visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChildren(_parameters, visitor);
-    safelyVisitChildren(_typeVariables, visitor);
-  }
-  void appendTo(JavaStringBuilder builder) {
-    builder.append("typedef ");
-    builder.append(name);
-    int variableCount = _typeVariables.length;
-    if (variableCount > 0) {
-      builder.append("<");
-      for (int i = 0; i < variableCount; i++) {
-        if (i > 0) {
-          builder.append(", ");
-        }
-        ((_typeVariables[i] as TypeVariableElementImpl)).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);
-    }
-    builder.append(")");
-    if (_type != null) {
-      builder.append(" -> ");
-      builder.append(_type.returnType);
-    }
-  }
-}
-/**
  * Instances of the class {@code TypeVariableElementImpl} implement a {@code TypeVariableElement}.
  * @coverage dart.engine.element
  */
 class TypeVariableElementImpl extends ElementImpl implements TypeVariableElement {
   /**
    * The type defined by this type variable.
    */
   TypeVariableType _type;
   /**
    * The type representing the bound associated with this variable, or {@code null} if this variable
@@ skipping 52 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_196_impl(name);
+    _jtd_constructor_207_impl(name);
   }
-  _jtd_constructor_196_impl(Identifier name) {
+  _jtd_constructor_207_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_197_impl(name, nameOffset);
+    _jtd_constructor_208_impl(name, nameOffset);
   }
-  _jtd_constructor_197_impl(String name, int nameOffset) {
+  _jtd_constructor_208_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;
   bool isConst() => hasModifier(Modifier.CONST);
   bool isFinal() => hasModifier(Modifier.FINAL);
   /**
    * Set whether this variable is const to correspond to the given value.
    * @param isConst {@code true} if the variable is const
    */
-  void set const2(bool isConst) {
+  void set const3(bool isConst) {
     setModifier(Modifier.CONST, isConst);
   }
   /**
+   * Set the result of evaluating this variable's initializer as a compile-time constant expression
+   * to the given result.
+   * @param result the result of evaluating this variable's initializer
+   */
+  void set evaluationResult(EvaluationResultImpl result) {
+    throw new IllegalStateException("Invalid attempt to set a compile-time constant result");
+  }
+  /**
    * Set whether this variable is final to correspond to the given value.
    * @param isFinal {@code true} if the variable is final
    */
   void set final2(bool isFinal) {
     setModifier(Modifier.FINAL, isFinal);
   }
   /**
    * Set the function representing this variable's initializer to the given function.
    * @param initializer the function representing this variable's initializer
    */
@@ skipping 144 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_248_impl(element);
+    _jtd_constructor_259_impl(element);
   }
-  _jtd_constructor_248_impl(ExecutableElement element) {
+  _jtd_constructor_259_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(TypeAliasElement element) : super(element, element == null ? null : element.name) {
-    _jtd_constructor_249_impl(element);
+  FunctionTypeImpl.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name) {
+    _jtd_constructor_260_impl(element);
   }
-  _jtd_constructor_249_impl(TypeAliasElement element) {
+  _jtd_constructor_260_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 element39 = element;
-    if (element39 == null) {
+    Element element40 = element;
+    if (element40 == null) {
       return 0;
     }
-    return element39.hashCode;
+    return element40.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 element40 = element;
-    FunctionTypeImpl newType = (element40 is ExecutableElement) ? new FunctionTypeImpl.con1((element40 as ExecutableElement)) : new FunctionTypeImpl.con2((element40 as TypeAliasElement));
+    Element element41 = element;
+    FunctionTypeImpl newType = (element41 is ExecutableElement) ? new FunctionTypeImpl.con1((element41 as ExecutableElement)) : new FunctionTypeImpl.con2((element41 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 element41 = type.element;
-    if (element41 != null && element41 is ClassElement) {
-      ClassElement classElement = element41 as ClassElement;
+    Element element42 = type.element;
+    if (element42 != null && element42 is ClassElement) {
+      ClassElement classElement = element42 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_250_impl(element);
+    _jtd_constructor_261_impl(element);
   }
-  _jtd_constructor_250_impl(ClassElement element) {
+  _jtd_constructor_261_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_251_impl(name);
+    _jtd_constructor_262_impl(name);
   }
-  _jtd_constructor_251_impl(String name) {
+  _jtd_constructor_262_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 element42 = element;
-    if (element42 == null) {
+    ClassElement element43 = element;
+    if (element43 == null) {
       return 0;
     }
-    return element42.hashCode;
+    return element43.hashCode;
   }
   bool isDartCoreFunction() {
-    ClassElement element43 = element;
-    if (element43 == null) {
+    ClassElement element44 = element;
+    if (element44 == null) {
       return false;
     }
-    return element43.name == "Function" && element43.library.isDartCore();
+    return element44.name == "Function" && element44.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);
 }