Update 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;
@@ skipping 85 matching lines @@
    * @return the unnamed constructor defined in this class
    */
   ConstructorElement get unnamedConstructor;
   /**
    * Return {@code true} if this class is abstract. A class is abstract if it has an explicit{@code abstract} modifier. Note, that this definition of <i>abstract</i> is different from
    * <i>has unimplemented members</i>.
    * @return {@code true} if this class is abstract
    */
   bool isAbstract();
   /**
+   * Return {@code true} if this class is defined by a typedef construct.
+   * @return {@code true} if this class is defined by a typedef construct
+   */
+  bool isTypedef();
+  /**
+   * Return {@code true} if this class can validly be used as a mixin when defining another class.
+   * The behavior of this method is defined by the Dart Language Specification in section 9:
+   * <blockquote>It is a compile-time error if a declared or derived mixin refers to super. It is a
+   * compile-time error if a declared or derived mixin explicitly declares a constructor. It is a
+   * compile-time error if a mixin is derived from a class whose superclass is not
+   * Object.</blockquote>
+   * @return {@code true} if this class can validly be used as a mixin
+   */
+  bool isValidMixin();
+  /**
    * Return the element representing the getter that results from looking up the given getter in
    * this class with respect to the given library, or {@code null} if the look up fails. The
    * behavior of this method is defined by the Dart Language Specification in section 12.15.1:
-   * <blockquote> The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
+   * <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
    * with respect to library <i>L</i> is:
    * <ul>
    * <li>If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
    * accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
    * Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
    * of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
    * Otherwise, we say that the lookup has failed.</li>
    * </ul>
    * </blockquote>
    * @param getterName the name of the getter being looked up
@@ skipping 67 matching lines @@
    * Return an array containing all of the type aliases contained in this compilation unit.
    * @return the type aliases contained in this compilation unit
    */
   List<TypeAliasElement> get typeAliases;
   /**
    * 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;
   /**
-   * Return an array containing all of the variables contained in this compilation unit.
-   * @return the variables contained in this compilation unit
+   * 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<VariableElement> get variables;
+  List<TopLevelVariableElement> get topLevelVariables;
 }
 /**
  * The interface {@code ConstructorElement} defines the behavior of elements representing a
  * constructor or a factory method defined within a type.
  */
 abstract class ConstructorElement implements ExecutableElement {
   /**
    * Return the type in which this constructor is defined.
    * @return the type in which this constructor is defined
    */
@@ skipping 24 matching lines @@
  * <li>fields that are induced by explicit declarations of getters and setters, and
  * <li>functions representing the initialization expression for a variable.
  * </ul>
  * <p>
  * Second, there are elements in the element model that do not have a name. These correspond to
  * unnamed functions and exist in order to more accurately represent the semantic structure of the
  * program.
  */
 abstract class Element {
   /**
+   * A comparator that can be used to sort elements by their name offset. Elements with a smaller
+   * offset will be sorted to be before elements with a larger name offset.
+   */
+  static Comparator<Element> SORT_BY_OFFSET = (Element firstElement, Element secondElement) => firstElement.nameOffset - secondElement.nameOffset;
+  /**
+   * Use the given visitor to visit this element.
+   * @param visitor the visitor that will visit this element
+   * @return the value returned by the visitor as a result of visiting this element
+   */
+  accept(ElementVisitor visitor);
+  /**
    * Return the element of the given class that most immediately encloses this element, or{@code null} if there is no enclosing element of the given class.
    * @param elementClass the class of the element to be returned
    * @return the element that encloses this element
    */
   Element getAncestor(Type elementClass);
   /**
    * Return the analysis context in which this element is defined.
    * @return the analysis context in which this element is defined
    */
   AnalysisContext get context;
@@ skipping 52 matching lines @@
    * @return {@code true} if this element is accessible to code in the given library
    */
   bool isAccessibleIn(LibraryElement library);
   /**
    * Return {@code true} if this element is synthetic. A synthetic element is an element that is not
    * represented in the source code explicitly, but is implied by the source code, such as the
    * default constructor for a class that does not explicitly define any constructors.
    * @return {@code true} if this element is synthetic
    */
   bool isSynthetic();
+  /**
+   * Use the given visitor to visit all of the children of this element. There is no guarantee of
+   * the order in which the children will be visited.
+   * @param visitor the visitor that will be used to visit the children of this element
+   */
+  void visitChildren(ElementVisitor<Object> visitor);
 }
 /**
  * The enumeration {@code ElementKind} defines the various kinds of elements in the element model.
  */
 class ElementKind {
-  static final ElementKind CLASS = new ElementKind('CLASS', 0);
-  static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 1);
-  static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 2);
-  static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 3);
-  static final ElementKind ERROR = new ElementKind('ERROR', 4);
-  static final ElementKind EXPORT = new ElementKind('EXPORT', 5);
-  static final ElementKind FIELD = new ElementKind('FIELD', 6);
-  static final ElementKind FUNCTION = new ElementKind('FUNCTION', 7);
-  static final ElementKind GETTER = new ElementKind('GETTER', 8);
-  static final ElementKind HTML = new ElementKind('HTML', 9);
-  static final ElementKind IMPORT = new ElementKind('IMPORT', 10);
-  static final ElementKind LABEL = new ElementKind('LABEL', 11);
-  static final ElementKind LIBRARY = new ElementKind('LIBRARY', 12);
-  static final ElementKind METHOD = new ElementKind('METHOD', 13);
-  static final ElementKind NAME = new ElementKind('NAME', 14);
-  static final ElementKind PARAMETER = new ElementKind('PARAMETER', 15);
-  static final ElementKind PREFIX = new ElementKind('PREFIX', 16);
-  static final ElementKind SETTER = new ElementKind('SETTER', 17);
-  static final ElementKind TYPE_ALIAS = new ElementKind('TYPE_ALIAS', 18);
-  static final ElementKind TYPE_VARIABLE = new ElementKind('TYPE_VARIABLE', 19);
-  static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 20);
-  static final ElementKind VARIABLE = new ElementKind('VARIABLE', 21);
-  static final List<ElementKind> values = [CLASS, COMPILATION_UNIT, CONSTRUCTOR, DYNAMIC, ERROR, EXPORT, FIELD, FUNCTION, GETTER, HTML, IMPORT, LABEL, LIBRARY, METHOD, NAME, PARAMETER, PREFIX, SETTER, TYPE_ALIAS, TYPE_VARIABLE, UNIVERSE, VARIABLE];
+  static final ElementKind CLASS = new ElementKind('CLASS', 0, "class");
+  static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 1, "compilation unit");
+  static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 2, "constructor");
+  static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 3, "<dynamic>");
+  static final ElementKind ERROR = new ElementKind('ERROR', 4, "<error>");
+  static final ElementKind EXPORT = new ElementKind('EXPORT', 5, "export directive");
+  static final ElementKind FIELD = new ElementKind('FIELD', 6, "field");
+  static final ElementKind FUNCTION = new ElementKind('FUNCTION', 7, "function");
+  static final ElementKind GETTER = new ElementKind('GETTER', 8, "getter");
+  static final ElementKind HTML = new ElementKind('HTML', 9, "html");
+  static final ElementKind IMPORT = new ElementKind('IMPORT', 10, "import directive");
+  static final ElementKind LABEL = new ElementKind('LABEL', 11, "label");
+  static final ElementKind LIBRARY = new ElementKind('LIBRARY', 12, "library");
+  static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 13, "local variable");
+  static final ElementKind METHOD = new ElementKind('METHOD', 14, "method");
+  static final ElementKind NAME = new ElementKind('NAME', 15, "<name>");
+  static final ElementKind PARAMETER = new ElementKind('PARAMETER', 16, "parameter");
+  static final ElementKind PREFIX = new ElementKind('PREFIX', 17, "import prefix");
+  static final ElementKind SETTER = new ElementKind('SETTER', 18, "setter");
+  static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 19, "top level variable");
+  static final ElementKind TYPE_ALIAS = new ElementKind('TYPE_ALIAS', 20, "function type alias");
+  static final ElementKind TYPE_VARIABLE = new ElementKind('TYPE_VARIABLE', 21, "type variable");
+  static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 22, "<universe>");
+  static final List<ElementKind> values = [CLASS, COMPILATION_UNIT, CONSTRUCTOR, DYNAMIC, ERROR, EXPORT, FIELD, FUNCTION, GETTER, HTML, IMPORT, LABEL, LIBRARY, LOCAL_VARIABLE, METHOD, NAME, PARAMETER, PREFIX, SETTER, TOP_LEVEL_VARIABLE, TYPE_ALIAS, TYPE_VARIABLE, UNIVERSE];
   final String __name;
   final int __ordinal;
-  ElementKind(this.__name, this.__ordinal) {
+  String _displayName;
+  ElementKind(this.__name, this.__ordinal, String displayName) {
+    this._displayName = displayName;
   }
+  /**
+   * @return the name of this {@link ElementKind} to display in UI.
+   */
+  String get displayName => _displayName;
   String toString() => __name;
 }
 /**
  * The interface {@code ElementLocation} defines the behavior of objects that represent the location
  * of an element within the element model.
  */
 abstract class ElementLocation {
   /**
    * Return an encoded representation of this location that can be used to create a location that is
    * equal to this location.
    * @return an encoded representation of this location
    */
   String get encoding;
 }
 /**
+ * The interface {@code ElementVisitor} defines the behavior of objects that can be used to visit an
+ * element structure.
+ */
+abstract class ElementVisitor<R> {
+  R visitClassElement(ClassElement element);
+  R visitCompilationUnitElement(CompilationUnitElement element);
+  R visitConstructorElement(ConstructorElement element);
+  R visitExportElement(ExportElement element);
+  R visitFieldElement(FieldElement element);
+  R visitFunctionElement(FunctionElement element);
+  R visitHtmlElement(HtmlElement element);
+  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 visitTypeVariableElement(TypeVariableElement element);
+}
+/**
  * The interface {@code ExecutableElement} defines the behavior of elements representing an
  * executable object, including functions, methods, constructors, getters, and setters.
  */
 abstract class ExecutableElement implements Element {
   /**
    * Return an array containing all of the functions defined within this executable element.
    * @return the functions defined within this executable element
    */
-  List<ExecutableElement> get functions;
+  List<FunctionElement> get functions;
   /**
    * Return an array containing all of the labels defined within this executable element.
    * @return the labels defined within this executable element
    */
   List<LabelElement> get labels;
   /**
    * Return an array containing all of the local variables defined within this executable element.
    * @return the local variables defined within this executable element
    */
-  List<VariableElement> get localVariables;
+  List<LocalVariableElement> get localVariables;
   /**
    * 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 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.
  */
 abstract class ExportElement implements Element {
   /**
    * An empty array of export elements.
    */
   static List<ExportElement> EMPTY_ARRAY = new List<ExportElement>(0);
   /**
    * Return an array containing the combinators that were specified as part of the export directive
    * in the order in which they were specified.
    * @return the combinators specified in the export directive
    */
   List<NamespaceCombinator> get combinators;
   /**
    * Return the library that is exported from this library by this export directive.
    * @return the library that is exported from this library
    */
   LibraryElement get exportedLibrary;
 }
 /**
  * The interface {@code FieldElement} defines the behavior of elements representing a field defined
- * within a type. Note that explicitly defined fields implicitly define a synthetic getter and that
- * non-{@code final} explicitly defined fields implicitly define a synthetic setter. Symmetrically,
- * synthetic fields are implicitly created for explicitly defined getters and setters. The following
- * rules apply:
- * <ul>
- * <li>Every explicit field is represented by a non-synthetic {@link FieldElement}.
- * <li>Every explicit field induces a getter and possibly a setter, both of which are represented by
- * synthetic {@link PropertyAccessorElement}s.
- * <li>Every explicit getter or setter is represented by a non-synthetic{@link PropertyAccessorElement}.
- * <li>Every explicit getter or setter (or pair thereof if they have the same name) induces a field
- * that is represented by a synthetic {@link FieldElement}.
- * </ul>
+ * within a type.
  */
-abstract class FieldElement implements VariableElement {
+abstract class FieldElement implements PropertyInducingElement {
   /**
-   * Return the getter associated with this field. If this field was explicitly defined (is not
-   * synthetic) then the getter associated with it will be synthetic.
-   * @return the getter associated with this field
+   * Return the type in which this field is defined.
+   * @return the type in which this field is defined
    */
-  PropertyAccessorElement get getter;
-  /**
-   * Return the setter associated with this field, or {@code null} if the field is effectively{@code final} and therefore does not have a setter associated with it. (This can happen either
-   * because the field is explicitly defined as being {@code final} or because the field is induced
-   * by an explicit getter that does not have a corresponding setter.) If this field was explicitly
-   * defined (is not synthetic) then the setter associated with it will be synthetic.
-   * @return the setter associated with this field
-   */
-  PropertyAccessorElement get setter;
-  /**
-   * Return {@code true} if this field is a static field.
-   * @return {@code true} if this field is a static field
-   */
-  bool isStatic();
+  ClassElement get enclosingElement;
 }
 /**
  * The interface {@code FunctionElement} defines the behavior of elements representing a function.
  */
-abstract class FunctionElement implements ExecutableElement {
-  /**
-   * Return a source range that covers the approximate portion of the source in which the name of
-   * this function is visible, or {@code null} if there is no single range of characters within
-   * which the variable's name is visible.
-   * <ul>
-   * <li>For a local function, this includes everything from the beginning of the function's body to
-   * the end of the block that encloses the function declaration.</li>
-   * <li>For top-level functions, {@code null} will be returned because they are potentially visible
-   * in multiple sources.</li>
-   * </ul>
-   * @return the range of characters in which the name of this function is visible
-   */
-  SourceRange get visibleRange;
+abstract class FunctionElement implements ExecutableElement, LocalElement {
 }
 /**
  * The interface {@code HideCombinator} defines the behavior of combinators that cause some of the
  * names in a namespace to be hidden when being imported.
  */
 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 97 matching lines @@
    * Return an array containing elements for each of the prefixes used to {@code import} libraries
    * into this library. Each prefix can be used in more than one {@code import} directive.
    * @return the prefixes used to {@code import} libraries into this library
    */
   List<PrefixElement> get prefixes;
   /**
    * Answer {@code true} if this library is an application that can be run in the browser.
    * @return {@code true} if this library is an application that can be run in the browser
    */
   bool isBrowserApplication();
+  /**
+   * Return {@code true} if this library is the dart:core library.
+   * @return {@code true} if this library is the dart:core library
+   */
+  bool isDartCore();
+}
+/**
+ * The interface {@code LocalElement} defines the behavior of elements that can be (but are not
+ * required to be) defined within a method or function (an {@link ExecutableElement}).
+ */
+abstract class LocalElement implements Element {
+  /**
+   * Return a source range that covers the approximate portion of the source in which the name of
+   * this element is visible, or {@code null} if there is no single range of characters within which
+   * the element name is visible.
+   * <ul>
+   * <li>For a local variable, this includes everything from the end of the variable's initializer
+   * to the end of the block that encloses the variable declaration.</li>
+   * <li>For a parameter, this includes the body of the method or function that declares the
+   * parameter.</li>
+   * <li>For a local function, this includes everything from the beginning of the function's body to
+   * the end of the block that encloses the function declaration.</li>
+   * <li>For top-level functions, {@code null} will be returned because they are potentially visible
+   * in multiple sources.</li>
+   * </ul>
+   * @return the range of characters in which the name of this element is visible
+   */
+  SourceRange get visibleRange;
+}
+/**
+ * The interface {@code LocalVariableElement} defines the behavior common to elements that represent
+ * a local variable.
+ */
+abstract class LocalVariableElement implements LocalElement, VariableElement {
 }
 /**
  * The interface {@code MethodElement} defines the behavior of elements that represent a method
  * defined within a type.
  */
 abstract class MethodElement implements ExecutableElement {
   /**
    * 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 static. Methods are static if they have been marked as
-   * being static using the {@code static} modifier.
-   * @return {@code true} if this method is static
-   */
-  bool isStatic();
 }
 /**
  * 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.
  */
 abstract class MultiplyDefinedElement implements Element {
   /**
@@ skipping 10 matching lines @@
 abstract class NamespaceCombinator {
   /**
    * An empty array of namespace combinators.
    */
   static List<NamespaceCombinator> EMPTY_ARRAY = new List<NamespaceCombinator>(0);
 }
 /**
  * The interface {@code ParameterElement} defines the behavior of elements representing a parameter
  * defined within an executable element.
  */
-abstract class ParameterElement implements VariableElement {
+abstract class ParameterElement implements LocalElement, VariableElement {
   /**
    * Return the kind of this parameter.
    * @return the kind of this parameter
    */
   ParameterKind get parameterKind;
   /**
    * Return {@code true} if this parameter is an initializing formal parameter.
    * @return {@code true} if this parameter is an initializing formal parameter
    */
   bool isInitializingFormal();
@@ skipping 23 matching lines @@
  * <li>Every explicit field is represented by a non-synthetic {@link FieldElement}.
  * <li>Every explicit field induces a getter and possibly a setter, both of which are represented by
  * synthetic {@link PropertyAccessorElement}s.
  * <li>Every explicit getter or setter is represented by a non-synthetic{@link PropertyAccessorElement}.
  * <li>Every explicit getter or setter (or pair thereof if they have the same name) induces a field
  * that is represented by a synthetic {@link FieldElement}.
  * </ul>
  */
 abstract class PropertyAccessorElement implements ExecutableElement {
   /**
-   * Return the field associated with this accessor. If this accessor was explicitly defined (is not
-   * synthetic) then the field associated with it will be synthetic.
-   * @return the field associated with this accessor
+   * Return the field or top-level variable associated with this accessor. If this accessor was
+   * explicitly defined (is not synthetic) then the variable associated with it will be synthetic.
+   * @return the variable associated with this accessor
    */
-  FieldElement get field;
+  PropertyInducingElement get variable;
   /**
    * Return {@code true} if this accessor represents a getter.
    * @return {@code true} if this accessor represents a getter
    */
   bool isGetter();
   /**
    * Return {@code true} if this accessor represents a setter.
    * @return {@code true} if this accessor represents a setter
    */
   bool isSetter();
 }
 /**
+ * The interface {@code PropertyInducingElement} defines the behavior of elements representing a
+ * variable that has an associated getter and possibly a setter. Note that explicitly defined
+ * variables implicitly define a synthetic getter and that non-{@code final} explicitly defined
+ * variables implicitly define a synthetic setter. Symmetrically, synthetic fields are implicitly
+ * created for explicitly defined getters and setters. The following rules apply:
+ * <ul>
+ * <li>Every explicit variable is represented by a non-synthetic {@link PropertyInducingElement}.
+ * <li>Every explicit variable induces a getter and possibly a setter, both of which are represented
+ * by synthetic {@link PropertyAccessorElement}s.
+ * <li>Every explicit getter or setter is represented by a non-synthetic{@link PropertyAccessorElement}.
+ * <li>Every explicit getter or setter (or pair thereof if they have the same name) induces a
+ * variable that is represented by a synthetic {@link PropertyInducingElement}.
+ * </ul>
+ */
+abstract class PropertyInducingElement implements VariableElement {
+  /**
+   * Return the getter associated with this variable. If this variable was explicitly defined (is
+   * not synthetic) then the getter associated with it will be synthetic.
+   * @return the getter associated with this variable
+   */
+  PropertyAccessorElement get getter;
+  /**
+   * Return the setter associated with this variable, or {@code null} if the variable is effectively{@code final} and therefore does not have a setter associated with it. (This can happen either
+   * because the variable is explicitly defined as being {@code final} or because the variable is
+   * induced by an explicit getter that does not have a corresponding setter.) If this variable was
+   * explicitly defined (is not synthetic) then the setter associated with it will be synthetic.
+   * @return the setter associated with this variable
+   */
+  PropertyAccessorElement get setter;
+  /**
+   * 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 ShowCombinator} defines the behavior of combinators that cause some of the
  * names in a namespace to be visible (and the rest hidden) when being imported.
  */
 abstract class ShowCombinator implements NamespaceCombinator {
   /**
    * Return an array containing the names that are to be made visible in the importing library if
    * they are defined in the imported library.
    * @return the names from the imported library that are visible in the importing library
    */
   List<String> get shownNames;
 }
 /**
+ * The interface {@code TopLevelVariableElement} defines the behavior of elements representing a
+ * top-level variable.
+ */
+abstract class TopLevelVariableElement implements PropertyInducingElement {
+}
+/**
  * The interface {@code TypeAliasElement} defines the behavior of elements representing a type alias
  * ({@code typedef}).
  */
 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;
   /**
@@ skipping 49 matching lines @@
    * @return a synthetic function representing this variable's initializer
    */
   FunctionElement get initializer;
   /**
    * Return the declared type of this variable, or {@code null} if the variable did not have a
    * declared type (such as if it was declared using the keyword 'var').
    * @return the declared type of this variable
    */
   Type2 get type;
   /**
-   * Return a source range that covers the approximate portion of the source in which the name of
-   * this variable is visible, or {@code null} if there is no single range of characters within
-   * which the variable's name is visible.
-   * <ul>
-   * <li>For a local variable, this includes everything from the end of the variable's initializer
-   * to the end of the block that encloses the variable declaration.</li>
-   * <li>For a parameter, this includes the body of the method or function that declares the
-   * parameter.</li>
-   * <li>For fields and top-level variables, {@code null} will be returned because they are
-   * potentially visible in multiple sources.</li>
-   * </ul>
-   * @return the range of characters in which the name of this variable is visible
-   */
-  SourceRange get visibleRange;
-  /**
    * Return {@code true} if this variable is a const variable. Variables are const if they have been
    * marked as being const using the {@code const} modifier.
    * @return {@code true} if this variable is a const variable
    */
   bool isConst();
   /**
    * Return {@code true} if this variable is a final variable. Variables are final if they have been
    * marked as being final using either the {@code final} or {@code const} modifiers.
    * @return {@code true} if this variable is a final variable
    */
   bool isFinal();
 }
 /**
+ * Instances of the class {@code GeneralizingElementVisitor} implement an element visitor that will
+ * recursively visit all of the elements in an element model (like instances of the class{@link RecursiveElementVisitor}). In addition, when an element of a specific type is visited not
+ * only will the visit method for that specific type of element be invoked, but additional methods
+ * for the supertypes of that element will also be invoked. For example, using an instance of this
+ * class to visit a {@link MethodElement} will cause the method{@link #visitMethodElement(MethodElement)} to be invoked but will also cause the methods{@link #visitExecutableElement(ExecutableElement)} and {@link #visitElement(Element)} to be
+ * subsequently invoked. This allows visitors to be written that visit all executable elements
+ * without needing to override the visit method for each of the specific subclasses of{@link ExecutableElement}.
+ * <p>
+ * Note, however, that unlike many visitors, element visitors visit objects based on the interfaces
+ * implemented by those elements. Because interfaces form a graph structure rather than a tree
+ * structure the way classes do, and because it is generally undesirable for an object to be visited
+ * more than once, this class flattens the interface graph into a pseudo-tree. In particular, this
+ * class treats elements as if the element types were structured in the following way:
+ * <p>
+ * <pre>
+ * Element
+ * ClassElement
+ * CompilationUnitElement
+ * ExecutableElement
+ * ConstructorElement
+ * LocalElement
+ * FunctionElement
+ * MethodElement
+ * PropertyAccessorElement
+ * ExportElement
+ * HtmlElement
+ * ImportElement
+ * LabelElement
+ * LibraryElement
+ * MultiplyDefinedElement
+ * PrefixElement
+ * TypeAliasElement
+ * TypeVariableElement
+ * UndefinedElement
+ * VariableElement
+ * PropertyInducingElement
+ * FieldElement
+ * TopLevelVariableElement
+ * LocalElement
+ * LocalVariableElement
+ * ParameterElement
+ * </pre>
+ * <p>
+ * Subclasses that override a visit method must either invoke the overridden visit method or
+ * explicitly invoke the more general visit method. Failure to do so will cause the visit methods
+ * for superclasses of the element to not be invoked and will cause the children of the visited node
+ * to not be visited.
+ */
+class GeneralizingElementVisitor<R> implements ElementVisitor<R> {
+  R visitClassElement(ClassElement element) => visitElement(element);
+  R visitCompilationUnitElement(CompilationUnitElement element) => visitElement(element);
+  R visitConstructorElement(ConstructorElement element) => visitExecutableElement(element);
+  R visitElement(Element element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitExecutableElement(ExecutableElement element) => visitElement(element);
+  R visitExportElement(ExportElement element) => visitElement(element);
+  R visitFieldElement(FieldElement element) => visitPropertyInducingElement(element);
+  R visitFunctionElement(FunctionElement element) => visitLocalElement(element);
+  R visitHtmlElement(HtmlElement element) => visitElement(element);
+  R visitImportElement(ImportElement element) => visitElement(element);
+  R visitLabelElement(LabelElement element) => visitElement(element);
+  R visitLibraryElement(LibraryElement element) => visitElement(element);
+  R visitLocalElement(LocalElement element) {
+    if (element is LocalVariableElement) {
+      return visitVariableElement((element as LocalVariableElement));
+    } else if (element is ParameterElement) {
+      return visitVariableElement((element as ParameterElement));
+    } else if (element is FunctionElement) {
+      return visitExecutableElement((element as FunctionElement));
+    }
+    return null;
+  }
+  R visitLocalVariableElement(LocalVariableElement element) => visitLocalElement(element);
+  R visitMethodElement(MethodElement element) => visitExecutableElement(element);
+  R visitMultiplyDefinedElement(MultiplyDefinedElement element) => visitElement(element);
+  R visitParameterElement(ParameterElement element) => visitLocalElement(element);
+  R visitPrefixElement(PrefixElement element) => visitElement(element);
+  R visitPropertyAccessorElement(PropertyAccessorElement element) => visitExecutableElement(element);
+  R visitPropertyInducingElement(PropertyInducingElement element) => visitVariableElement(element);
+  R visitTopLevelVariableElement(TopLevelVariableElement element) => visitPropertyInducingElement(element);
+  R visitTypeAliasElement(TypeAliasElement 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
+ * explicitly ask the visited element to visit its children. Failure to do so will cause the
+ * children of the visited element to not be visited.
+ */
+class RecursiveElementVisitor<R> implements ElementVisitor<R> {
+  R visitClassElement(ClassElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitCompilationUnitElement(CompilationUnitElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitConstructorElement(ConstructorElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitExportElement(ExportElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitFieldElement(FieldElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitFunctionElement(FunctionElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitHtmlElement(HtmlElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitImportElement(ImportElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitLabelElement(LabelElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitLibraryElement(LibraryElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitLocalVariableElement(LocalVariableElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitMethodElement(MethodElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitMultiplyDefinedElement(MultiplyDefinedElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitParameterElement(ParameterElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitPrefixElement(PrefixElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitPropertyAccessorElement(PropertyAccessorElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitTopLevelVariableElement(TopLevelVariableElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+  R visitTypeAliasElement(TypeAliasElement 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
+ * nothing when visiting an element. It is intended to be a superclass for classes that use the
+ * visitor pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a
+ * whole structure) and that only need to visit a small number of element types.
+ */
+class SimpleElementVisitor<R> implements ElementVisitor<R> {
+  R visitClassElement(ClassElement element) => null;
+  R visitCompilationUnitElement(CompilationUnitElement element) => null;
+  R visitConstructorElement(ConstructorElement element) => null;
+  R visitExportElement(ExportElement element) => null;
+  R visitFieldElement(FieldElement element) => null;
+  R visitFunctionElement(FunctionElement element) => null;
+  R visitHtmlElement(HtmlElement element) => null;
+  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 visitTypeVariableElement(TypeVariableElement element) => null;
+}
+/**
  * Instances of the class {@code AnnotationImpl} implement an {@link Annotation}.
  */
 class AnnotationImpl implements Annotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
   Element _element;
   /**
    * An empty array of annotations.
    */
@@ skipping 53 matching lines @@
   /**
    * An empty array of type elements.
    */
   static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
   /**
    * Initialize a newly created class element to have the given name.
    * @param name the name of this element
    */
   ClassElementImpl(Identifier name) : super.con1(name) {
   }
+  accept(ElementVisitor visitor) => visitor.visitClassElement(this);
   List<PropertyAccessorElement> get accessors => _accessors;
   List<InterfaceType> get allSupertypes {
     Collection<InterfaceType> list = new Set<InterfaceType>();
     collectAllSupertypes(list);
     return new List.from(list);
   }
-  ElementImpl getChild(String identifier19) {
+  ElementImpl getChild(String identifier24) {
     for (PropertyAccessorElement accessor in _accessors) {
-      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier19) {
-        return (accessor as PropertyAccessorElementImpl);
+      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier24) {
+        return accessor as PropertyAccessorElementImpl;
       }
     }
     for (ConstructorElement constructor in _constructors) {
-      if (((constructor as ConstructorElementImpl)).identifier == identifier19) {
-        return (constructor as ConstructorElementImpl);
+      if (((constructor as ConstructorElementImpl)).identifier == identifier24) {
+        return constructor as ConstructorElementImpl;
       }
     }
     for (FieldElement field in _fields) {
-      if (((field as FieldElementImpl)).identifier == identifier19) {
-        return (field as FieldElementImpl);
+      if (((field as FieldElementImpl)).identifier == identifier24) {
+        return field as FieldElementImpl;
       }
     }
     for (MethodElement method in _methods) {
-      if (((method as MethodElementImpl)).identifier == identifier19) {
-        return (method as MethodElementImpl);
+      if (((method as MethodElementImpl)).identifier == identifier24) {
+        return method as MethodElementImpl;
       }
     }
     for (TypeVariableElement typeVariable in _typeVariables) {
-      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier19) {
-        return (typeVariable as TypeVariableElementImpl);
+      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier24) {
+        return typeVariable as TypeVariableElementImpl;
       }
     }
     return null;
   }
   List<ConstructorElement> get constructors => _constructors;
   List<FieldElement> get fields => _fields;
   List<InterfaceType> get interfaces => _interfaces;
   ElementKind get kind => ElementKind.CLASS;
   List<MethodElement> get methods => _methods;
   List<InterfaceType> get mixins => _mixins;
-  ConstructorElement getNamedConstructor(String name21) {
+  ConstructorElement getNamedConstructor(String name22) {
     for (ConstructorElement element in constructors) {
       String elementName = element.name;
-      if (elementName != null && elementName == name21) {
+      if (elementName != null && elementName == name22) {
         return element;
       }
     }
     return null;
   }
   InterfaceType get supertype => _supertype;
   InterfaceType get type => _type;
   List<TypeVariableElement> get typeVariables => _typeVariables;
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
       String name10 = element.name;
       if (name10 == null || name10.isEmpty) {
         return element;
       }
     }
     return null;
   }
   bool isAbstract() => hasModifier(Modifier.ABSTRACT);
+  bool isTypedef() => hasModifier(Modifier.TYPEDEF);
+  bool isValidMixin() => hasModifier(Modifier.MIXIN);
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
     PropertyAccessorElement element = getGetter(getterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     for (InterfaceType mixin in _mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         element = ((mixinElement as ClassElementImpl)).getGetter(getterName);
         if (element != null && element.isAccessibleIn(library)) {
@@ skipping 128 matching lines @@
    * Set the superclass of the class to the given type.
    * @param supertype the superclass of the class
    */
   void set supertype(InterfaceType supertype2) {
     this._supertype = supertype2;
   }
   /**
    * Set the type defined by the class to the given type.
    * @param type the type defined by the class
    */
-  void set type(InterfaceType type4) {
-    this._type = type4;
+  void set type(InterfaceType type5) {
+    this._type = type5;
+  }
+  /**
+   * Set whether this class is defined by a typedef construct to correspond to the given value.
+   * @param isTypedef {@code true} if the class is defined by a typedef construct
+   */
+  void set typedef(bool isTypedef) {
+    setModifier(Modifier.TYPEDEF, isTypedef);
   }
   /**
    * Set the type variables defined for this class to the given type variables.
    * @param typeVariables the type variables defined for this class
    */
   void set typeVariables(List<TypeVariableElement> typeVariables2) {
     for (TypeVariableElement typeVariable in typeVariables2) {
       ((typeVariable as TypeVariableElementImpl)).enclosingElement = this;
     }
     this._typeVariables = typeVariables2;
   }
+  /**
+   * Set whether this class is a valid mixin to correspond to the given value.
+   * @param isValidMixin {@code true} if this class can be used as a mixin
+   */
+  void set validMixin(bool isValidMixin) {
+    setModifier(Modifier.MIXIN, isValidMixin);
+  }
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChildren(_accessors, visitor);
+    safelyVisitChildren(_constructors, visitor);
+    safelyVisitChildren(_fields, visitor);
+    safelyVisitChildren(_methods, visitor);
+    safelyVisitChildren(_typeVariables, visitor);
+  }
   void appendTo(StringBuffer builder) {
     String name11 = name;
     if (name11 == null) {
-      builder.add("{unnamed class}");
+      builder.write("{unnamed class}");
     } else {
-      builder.add(name11);
+      builder.write(name11);
     }
     int variableCount = _typeVariables.length;
     if (variableCount > 0) {
-      builder.add("<");
+      builder.write("<");
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
-          builder.add(", ");
+          builder.write(", ");
         }
         ((_typeVariables[i] as TypeVariableElementImpl)).appendTo(builder);
       }
-      builder.add(">");
+      builder.write(">");
     }
   }
   void collectAllSupertypes(Collection<InterfaceType> list) {
     if (_supertype == null || list.contains(_supertype)) {
       return;
     }
     list.add(_supertype);
     ((_supertype.element as ClassElementImpl)).collectAllSupertypes(list);
     for (InterfaceType type in interfaces) {
       if (!list.contains(type)) {
@@ skipping 59 matching lines @@
    * compilation unit.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the top-level functions contained in this compilation unit.
    */
   List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the variables contained in this compilation unit.
    */
-  List<VariableElement> _variables = VariableElementImpl.EMPTY_ARRAY;
+  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.
    */
   List<TypeAliasElement> _typeAliases = TypeAliasElementImpl.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) {
   }
-  bool operator ==(Object object) => identical(this.runtimeType, object.runtimeType) && _source == ((object as CompilationUnitElementImpl)).source;
+  accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
+  bool operator ==(Object object) => identical(runtimeType, object.runtimeType) && _source == ((object as CompilationUnitElementImpl)).source;
   List<PropertyAccessorElement> get accessors => _accessors;
-  ElementImpl getChild(String identifier20) {
+  ElementImpl getChild(String identifier25) {
     for (PropertyAccessorElement accessor in _accessors) {
-      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier20) {
-        return (accessor as PropertyAccessorElementImpl);
+      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier25) {
+        return accessor as PropertyAccessorElementImpl;
       }
     }
     for (VariableElement variable in _variables) {
-      if (((variable as VariableElementImpl)).identifier == identifier20) {
-        return (variable as VariableElementImpl);
+      if (((variable as VariableElementImpl)).identifier == identifier25) {
+        return variable as VariableElementImpl;
       }
     }
     for (ExecutableElement function in _functions) {
-      if (((function as ExecutableElementImpl)).identifier == identifier20) {
-        return (function as ExecutableElementImpl);
+      if (((function as ExecutableElementImpl)).identifier == identifier25) {
+        return function as ExecutableElementImpl;
       }
     }
     for (TypeAliasElement typeAlias in _typeAliases) {
-      if (((typeAlias as TypeAliasElementImpl)).identifier == identifier20) {
-        return (typeAlias as TypeAliasElementImpl);
+      if (((typeAlias as TypeAliasElementImpl)).identifier == identifier25) {
+        return typeAlias as TypeAliasElementImpl;
       }
     }
     for (ClassElement type in _types) {
-      if (((type as ClassElementImpl)).identifier == identifier20) {
-        return (type as ClassElementImpl);
+      if (((type as ClassElementImpl)).identifier == identifier25) {
+        return type as ClassElementImpl;
       }
     }
     return null;
   }
-  LibraryElement get enclosingElement => (super.enclosingElement as LibraryElement);
+  LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
   List<FunctionElement> get functions => _functions;
   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;
-  List<VariableElement> get variables => _variables;
   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 10 matching lines @@
     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 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;
+  }
+  /**
    * Set the type aliases contained in this compilation unit to the given type aliases.
    * @param typeAliases the type aliases contained in this compilation unit
    */
   void set typeAliases(List<TypeAliasElement> typeAliases2) {
     for (TypeAliasElement typeAlias in typeAliases2) {
       ((typeAlias as TypeAliasElementImpl)).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;
     }
     this._types = types2;
   }
-  /**
-   * Set the variables contained in this compilation unit to the given variables.
-   * @param variables the variables contained in this compilation unit
-   */
-  void set variables(List<VariableElement> variables2) {
-    for (VariableElement field in variables2) {
-      ((field as VariableElementImpl)).enclosingElement = this;
-    }
-    this._variables = variables2;
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChildren(_accessors, visitor);
+    safelyVisitChildren(_functions, visitor);
+    safelyVisitChildren(_typeAliases, visitor);
+    safelyVisitChildren(_types, visitor);
+    safelyVisitChildren(_variables, visitor);
   }
   void appendTo(StringBuffer builder) {
     if (_source == null) {
-      builder.add("{compilation unit}");
+      builder.write("{compilation unit}");
     } else {
-      builder.add(_source.fullName);
+      builder.write(_source.fullName);
     }
   }
 }
 /**
  * Instances of the class {@code ConstructorElementImpl} implement a {@code ConstructorElement}.
  */
 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) {
   }
-  ClassElement get enclosingElement => (super.enclosingElement as ClassElement);
+  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 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(StringBuffer builder) {
-    builder.add(enclosingElement.name);
+    builder.write(enclosingElement.name);
     String name12 = name;
     if (name12 != null && !name12.isEmpty) {
-      builder.add(".");
-      builder.add(name12);
+      builder.write(".");
+      builder.write(name12);
     }
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code DynamicElementImpl} represent the synthetic element representing
  * the declaration of the type {@code dynamic}.
  */
 class DynamicElementImpl extends ElementImpl {
   /**
    * Return the unique instance of this class.
    * @return the unique instance of this class
    */
-  static DynamicElementImpl get instance => (DynamicTypeImpl.instance.element as DynamicElementImpl);
+  static DynamicElementImpl get instance => DynamicTypeImpl.instance.element as DynamicElementImpl;
   /**
    * The type defined by this element.
    */
   DynamicTypeImpl _type;
   /**
    * Initialize a newly created instance of this class. Instances of this class should <b>not</b> be
    * created except as part of creating the type associated with this element. The single instance
    * of this class should be accessed through the method {@link #getInstance()}.
    */
   DynamicElementImpl() : super.con2(Keyword.DYNAMIC.syntax, -1) {
     setModifier(Modifier.SYNTHETIC, true);
   }
+  accept(ElementVisitor visitor) => null;
   ElementKind get kind => ElementKind.DYNAMIC;
   /**
    * Return the type defined by this element.
    * @return the type defined by this element
    */
   DynamicTypeImpl get type => _type;
   /**
    * Set the type defined by this element to the given type.
    * @param type the type defined by this element
    */
-  void set type(DynamicTypeImpl type5) {
-    this._type = type5;
+  void set type(DynamicTypeImpl type6) {
+    this._type = type6;
   }
 }
 /**
  * The abstract class {@code ElementImpl} implements the behavior common to objects that implement
  * an {@link Element}.
  */
 abstract class ElementImpl implements Element {
   /**
    * The enclosing element of this element, or {@code null} if this element is at the root of the
    * element structure.
@@ skipping 13 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 name22) {
-    _jtd_constructor_135_impl(name22);
+  ElementImpl.con1(Identifier name23) {
+    _jtd_constructor_158_impl(name23);
   }
-  _jtd_constructor_135_impl(Identifier name22) {
-    _jtd_constructor_136_impl(name22 == null ? "" : name22.name, name22 == null ? -1 : name22.offset);
+  _jtd_constructor_158_impl(Identifier name23) {
+    _jtd_constructor_159_impl(name23 == null ? "" : name23.name, name23 == null ? -1 : name23.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_136_impl(name8, nameOffset2);
+    _jtd_constructor_159_impl(name8, nameOffset2);
   }
-  _jtd_constructor_136_impl(String name8, int nameOffset2) {
+  _jtd_constructor_159_impl(String name8, int nameOffset2) {
     this._name = name8;
     this._nameOffset = nameOffset2;
     this._modifiers = new Set();
   }
-  bool operator ==(Object object) => object is Element && ((object as Element)).location == location;
+  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;
     }
-    return (ancestor as Element);
+    return ancestor as Element;
   }
   /**
    * Return the child of this element that is uniquely identified by the given identifier, or{@code null} if there is no such child.
    * @param identifier the identifier used to select a child
    * @return the child of this element with the given identifier
    */
   ElementImpl getChild(String identifier) => null;
   AnalysisContext get context {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.context;
   }
   Element get enclosingElement => _enclosingElement;
   LibraryElement get library => getAncestor(LibraryElement);
   ElementLocation get location => new ElementLocationImpl.con1(this);
   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 library18) {
+  bool isAccessibleIn(LibraryElement library19) {
     if (Identifier.isPrivateName(_name)) {
-      return library18 == library;
+      return library19 == 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;
   }
   /**
    * Set whether this element is synthetic to correspond to the given value.
    * @param isSynthetic {@code true} if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
   String toString() {
     StringBuffer builder = new StringBuffer();
     appendTo(builder);
     return builder.toString();
   }
+  void visitChildren(ElementVisitor<Object> visitor) {
+  }
   /**
    * Append a textual representation of this type to the given builder.
    * @param builder the builder to which the text is to be appended
    */
   void appendTo(StringBuffer builder) {
     if (_name == null) {
-      builder.add("<unnamed ");
-      builder.add(runtimeType.toString());
-      builder.add(">");
+      builder.write("<unnamed ");
+      builder.write(runtimeType.toString());
+      builder.write(">");
     } else {
-      builder.add(_name);
+      builder.write(_name);
     }
   }
   /**
    * Return an identifier that uniquely identifies this element among the children of this element's
    * parent.
    * @return an identifier that uniquely identifies this element relative to its parent
    */
   String get identifier => name;
   /**
    * Return {@code true} if this element has the given modifier associated with it.
    * @param modifier the modifier being tested for
    * @return {@code true} if this element has the given modifier associated with it
    */
   bool hasModifier(Modifier modifier) => _modifiers.contains(modifier);
   /**
+   * If the given child is not {@code null}, use the given visitor to visit it.
+   * @param child the child to be visited
+   * @param visitor the visitor to be used to visit the child
+   */
+  void safelyVisitChild(Element child, ElementVisitor<Object> visitor) {
+    if (child != null) {
+      child.accept(visitor);
+    }
+  }
+  /**
+   * Use the given visitor to visit all of the children in the given array.
+   * @param children the children to be visited
+   * @param visitor the visitor being used to visit the children
+   */
+  void safelyVisitChildren(List<Element> children, ElementVisitor<Object> visitor) {
+    if (children != null) {
+      for (Element child in children) {
+        child.accept(visitor);
+      }
+    }
+  }
+  /**
    * Set the enclosing element of this element to the given element.
    * @param element the enclosing element of this element
    */
   void set enclosingElement(ElementImpl element) {
     _enclosingElement = element;
   }
   /**
    * Set whether the given modifier is associated with this element to correspond to the given
    * value.
    * @param modifier the modifier to be set
@@ skipping 17 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_137_impl(element);
+    _jtd_constructor_160_impl(element);
   }
-  _jtd_constructor_137_impl(Element element) {
+  _jtd_constructor_160_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_138_impl(encoding);
+    _jtd_constructor_161_impl(encoding);
   }
-  _jtd_constructor_138_impl(String encoding) {
+  _jtd_constructor_161_impl(String encoding) {
     this._components = decode(encoding);
   }
   bool operator ==(Object object) {
     if (object is! ElementLocationImpl) {
       return false;
     }
-    ElementLocationImpl location = (object as ElementLocationImpl);
+    ElementLocationImpl location = object as ElementLocationImpl;
     return JavaArrays.equals(_components, location._components);
   }
   /**
    * Return the path to the element whose location is represented by this object.
    * @return the path to the element whose location is represented by this object
    */
   List<String> get components => _components;
   String get encoding {
     StringBuffer builder = new StringBuffer();
     int length2 = _components.length;
     for (int i = 0; i < length2; i++) {
       if (i > 0) {
-        builder.addCharCode(_SEPARATOR_CHAR);
+        builder.writeCharCode(_SEPARATOR_CHAR);
       }
       encode(builder, _components[i]);
     }
     return builder.toString();
   }
   int get hashCode => JavaArrays.makeHashCode(_components);
   String toString() => encoding;
   /**
    * Decode the encoded form of a location into an array of components.
    * @param encoding the encoded form of a location
    * @return the components that were encoded
    */
   List<String> decode(String encoding) {
     List<String> components = new List<String>();
     StringBuffer builder = new StringBuffer();
     int index = 0;
     int length3 = encoding.length;
     while (index < length3) {
       int currentChar = encoding.codeUnitAt(index);
       if (currentChar == _SEPARATOR_CHAR) {
         if (index + 1 < length3 && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
-          builder.addCharCode(_SEPARATOR_CHAR);
+          builder.writeCharCode(_SEPARATOR_CHAR);
           index += 2;
         } else {
           components.add(builder.toString());
           builder.clear();
           index++;
         }
       } else {
-        builder.addCharCode(currentChar);
+        builder.writeCharCode(currentChar);
         index++;
       }
     }
     if (builder.length > 0) {
       components.add(builder.toString());
     }
     return new List.from(components);
   }
   /**
    * Append an encoded form of the given component to the given builder.
    * @param builder the builder to which the encoded component is to be appended
    * @param component the component to be appended to the builder
    */
   void encode(StringBuffer builder, String component) {
     int length4 = component.length;
     for (int i = 0; i < length4; i++) {
       int currentChar = component.codeUnitAt(i);
       if (currentChar == _SEPARATOR_CHAR) {
-        builder.addCharCode(_SEPARATOR_CHAR);
+        builder.writeCharCode(_SEPARATOR_CHAR);
       }
-      builder.addCharCode(currentChar);
+      builder.writeCharCode(currentChar);
     }
   }
 }
 /**
  * The abstract class {@code ExecutableElementImpl} implements the behavior common to{@code ExecutableElement}s.
  */
 abstract class ExecutableElementImpl extends ElementImpl implements ExecutableElement {
   /**
    * An array containing all of the functions defined within this executable element.
    */
-  List<ExecutableElement> _functions = EMPTY_ARRAY;
+  List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the labels defined within this executable element.
    */
   List<LabelElement> _labels = LabelElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the local variables defined within this executable element.
    */
-  List<VariableElement> _localVariables = VariableElementImpl.EMPTY_ARRAY;
+  List<LocalVariableElement> _localVariables = LocalVariableElementImpl.EMPTY_ARRAY;
   /**
    * An array containing all of the parameters defined by this executable element.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
   /**
    * The type of function defined by this executable element.
    */
   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_139_impl(name);
+    _jtd_constructor_162_impl(name);
   }
-  _jtd_constructor_139_impl(Identifier name) {
+  _jtd_constructor_162_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_140_impl(name, nameOffset);
+    _jtd_constructor_163_impl(name, nameOffset);
   }
-  _jtd_constructor_140_impl(String name, int nameOffset) {
+  _jtd_constructor_163_impl(String name, int nameOffset) {
   }
-  ElementImpl getChild(String identifier21) {
+  ElementImpl getChild(String identifier26) {
     for (ExecutableElement function in _functions) {
-      if (((function as ExecutableElementImpl)).identifier == identifier21) {
-        return (function as ExecutableElementImpl);
+      if (((function as ExecutableElementImpl)).identifier == identifier26) {
+        return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
-      if (((label as LabelElementImpl)).identifier == identifier21) {
-        return (label as LabelElementImpl);
+      if (((label as LabelElementImpl)).identifier == identifier26) {
+        return label as LabelElementImpl;
       }
     }
     for (VariableElement variable in _localVariables) {
-      if (((variable as VariableElementImpl)).identifier == identifier21) {
-        return (variable as VariableElementImpl);
+      if (((variable as VariableElementImpl)).identifier == identifier26) {
+        return variable as VariableElementImpl;
       }
     }
     for (ParameterElement parameter in _parameters) {
-      if (((parameter as ParameterElementImpl)).identifier == identifier21) {
-        return (parameter as ParameterElementImpl);
+      if (((parameter as ParameterElementImpl)).identifier == identifier26) {
+        return parameter as ParameterElementImpl;
       }
     }
     return null;
   }
-  List<ExecutableElement> get functions => _functions;
+  List<FunctionElement> get functions => _functions;
   List<LabelElement> get labels => _labels;
-  List<VariableElement> get localVariables => _localVariables;
+  List<LocalVariableElement> get localVariables => _localVariables;
   List<ParameterElement> get parameters => _parameters;
   FunctionType get type => _type;
   /**
    * 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<ExecutableElement> functions3) {
-    for (ExecutableElement function in functions3) {
-      ((function as ExecutableElementImpl)).enclosingElement = this;
+  void set functions(List<FunctionElement> functions3) {
+    for (FunctionElement function in functions3) {
+      ((function as FunctionElementImpl)).enclosingElement = this;
     }
     this._functions = functions3;
   }
   /**
    * Set the labels defined within this executable element to the given labels.
    * @param labels the labels defined within this executable element
    */
   void set labels(List<LabelElement> labels2) {
     for (LabelElement label in labels2) {
       ((label as LabelElementImpl)).enclosingElement = this;
     }
     this._labels = labels2;
   }
   /**
    * Set the local variables defined within this executable element to the given variables.
    * @param localVariables the local variables defined within this executable element
    */
-  void set localVariables(List<VariableElement> localVariables2) {
-    for (VariableElement variable in localVariables2) {
-      ((variable as VariableElementImpl)).enclosingElement = this;
+  void set localVariables(List<LocalVariableElement> localVariables2) {
+    for (LocalVariableElement variable in localVariables2) {
+      ((variable as LocalVariableElementImpl)).enclosingElement = this;
     }
     this._localVariables = localVariables2;
   }
   /**
    * Set the parameters defined by this executable element to the given parameters.
    * @param parameters the parameters defined by this executable element
    */
   void set parameters(List<ParameterElement> parameters7) {
     for (ParameterElement parameter in parameters7) {
       ((parameter as ParameterElementImpl)).enclosingElement = this;
     }
     this._parameters = parameters7;
   }
   /**
    * Set the type of function defined by this executable element to the given type.
    * @param type the type of function defined by this executable element
    */
-  void set type(FunctionType type6) {
-    this._type = type6;
+  void set type(FunctionType type7) {
+    this._type = type7;
+  }
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChildren(_functions, visitor);
+    safelyVisitChildren(_labels, visitor);
+    safelyVisitChildren(_localVariables, visitor);
+    safelyVisitChildren(_parameters, visitor);
   }
   void appendTo(StringBuffer builder) {
-    builder.add("(");
+    builder.write("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.add(", ");
+        builder.write(", ");
       }
       ((_parameters[i] as ParameterElementImpl)).appendTo(builder);
     }
-    builder.add(")");
+    builder.write(")");
     if (_type != null) {
-      builder.add(" -> ");
-      builder.add(_type.returnType);
+      builder.write(" -> ");
+      builder.write(_type.returnType);
     }
   }
 }
 /**
  * Instances of the class {@code ExportElementImpl} implement an {@link ExportElement}.
  */
 class ExportElementImpl extends ElementImpl implements ExportElement {
   /**
    * The library that is exported from this library by this export directive.
    */
   LibraryElement _exportedLibrary;
   /**
    * The combinators that were specified as part of the export directive in the order in which they
    * were specified.
    */
   List<NamespaceCombinator> _combinators = NamespaceCombinator.EMPTY_ARRAY;
   /**
    * Initialize a newly created export element.
    */
   ExportElementImpl() : super.con1(null) {
   }
+  accept(ElementVisitor visitor) => visitor.visitExportElement(this);
   List<NamespaceCombinator> get combinators => _combinators;
   LibraryElement get exportedLibrary => _exportedLibrary;
   ElementKind get kind => ElementKind.EXPORT;
   /**
    * Set the combinators that were specified as part of the export directive to the given array of
    * combinators.
    * @param combinators the combinators that were specified as part of the export directive
    */
   void set combinators(List<NamespaceCombinator> combinators2) {
     this._combinators = combinators2;
   }
   /**
    * Set the library that is exported from this library by this import directive to the given
    * library.
    * @param exportedLibrary the library that is exported from this library
    */
   void set exportedLibrary(LibraryElement exportedLibrary2) {
     this._exportedLibrary = exportedLibrary2;
   }
   void appendTo(StringBuffer builder) {
-    builder.add("export ");
+    builder.write("export ");
     ((_exportedLibrary as LibraryElementImpl)).appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code FieldElementImpl} implement a {@code FieldElement}.
  */
-class FieldElementImpl extends VariableElementImpl implements FieldElement {
-  /**
-   * The getter associated with this field.
-   */
-  PropertyAccessorElement _getter;
-  /**
-   * The setter associated with this field, or {@code null} if the field is effectively{@code final} and therefore does not have a setter associated with it.
-   */
-  PropertyAccessorElement _setter;
+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_142_impl(name);
+    _jtd_constructor_165_impl(name);
   }
-  _jtd_constructor_142_impl(Identifier name) {
+  _jtd_constructor_165_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, -1) {
-    _jtd_constructor_143_impl(name);
+  FieldElementImpl.con2(String name) : super.con2(name) {
+    _jtd_constructor_166_impl(name);
   }
-  _jtd_constructor_143_impl(String name) {
-    synthetic = true;
+  _jtd_constructor_166_impl(String name) {
   }
-  PropertyAccessorElement get getter => _getter;
+  accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
+  ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.FIELD;
-  PropertyAccessorElement get setter => _setter;
   bool isStatic() => hasModifier(Modifier.STATIC);
   /**
-   * Set the getter associated with this field to the given accessor.
-   * @param getter the getter associated with this field
-   */
-  void set getter(PropertyAccessorElement getter2) {
-    this._getter = getter2;
-  }
-  /**
-   * Set the setter associated with this field to the given accessor.
-   * @param setter the setter associated with this field
-   */
-  void set setter(PropertyAccessorElement setter2) {
-    this._setter = setter2;
-  }
-  /**
    * 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) {
     setModifier(Modifier.STATIC, isStatic);
   }
 }
 /**
  * Instances of the class {@code FunctionElementImpl} implement a {@code FunctionElement}.
  */
 class FunctionElementImpl extends ExecutableElementImpl implements FunctionElement {
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
   /**
    * 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 function elements.
    */
   static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>(0);
   /**
    * Initialize a newly created synthetic function element.
    */
   FunctionElementImpl() : super.con2("", -1) {
-    _jtd_constructor_144_impl();
+    _jtd_constructor_167_impl();
   }
-  _jtd_constructor_144_impl() {
+  _jtd_constructor_167_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_145_impl(name);
+    _jtd_constructor_168_impl(name);
   }
-  _jtd_constructor_145_impl(Identifier name) {
+  _jtd_constructor_168_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);
   }
+  bool isStatic() => enclosingElement is CompilationUnitElement;
   /**
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or {@code -1} if this element
    * does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
   void appendTo(StringBuffer builder) {
     String name13 = name;
     if (name13 != null) {
-      builder.add(name13);
+      builder.write(name13);
     }
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code ShowCombinatorImpl} implement a {@link ShowCombinator}.
  */
 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;
   /**
    * Initialize a newly created combinator.
    */
   HideCombinatorImpl() : super() {
   }
   List<String> get hiddenNames => _hiddenNames;
   /**
    * Set the names that are not to be made visible in the importing library even if they are defined
    * in the imported library to the given names.
    * @param hiddenNames the names that are not to be made visible in the importing library
    */
   void set hiddenNames(List<String> hiddenNames2) {
     this._hiddenNames = hiddenNames2;
   }
   String toString() {
     StringBuffer builder = new StringBuffer();
-    builder.add("show ");
+    builder.write("show ");
     int count = _hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.add(", ");
+        builder.write(", ");
       }
-      builder.add(_hiddenNames[i]);
+      builder.write(_hiddenNames[i]);
     }
     return builder.toString();
   }
 }
 /**
  * Instances of the class {@code HtmlElementImpl} implement an {@link HtmlElement}.
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty array of HTML file elements.
@@ skipping 12 matching lines @@
    */
   Source _source;
   /**
    * Initialize a newly created HTML element to have the given name.
    * @param context the analysis context in which the HTML file is defined
    * @param name the name of this element
    */
   HtmlElementImpl(AnalysisContext context, String name) : super.con2(name, -1) {
     this._context = context;
   }
-  bool operator ==(Object object) => identical(this.runtimeType, object.runtimeType) && _source == ((object as CompilationUnitElementImpl)).source;
+  accept(ElementVisitor visitor) => visitor.visitHtmlElement(this);
+  bool operator ==(Object object) => identical(runtimeType, object.runtimeType) && _source == ((object as CompilationUnitElementImpl)).source;
   AnalysisContext get context => _context;
   ElementKind get kind => ElementKind.HTML;
   List<LibraryElement> get libraries => _libraries;
   Source get source => _source;
   int get hashCode => _source.hashCode;
   /**
    * Set the libraries contained in or referenced from script tags in the HTML file to the given
    * libraries.
    * @param libraries the libraries contained in or referenced from script tags in the HTML file
    */
   void set libraries(List<LibraryElement> libraries2) {
     this._libraries = libraries2;
   }
   /**
    * 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 source6) {
     this._source = source6;
   }
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChildren(_libraries, visitor);
+  }
   void appendTo(StringBuffer builder) {
     if (_source == null) {
-      builder.add("{HTML file}");
+      builder.write("{HTML file}");
     } else {
-      builder.add(_source.fullName);
+      builder.write(_source.fullName);
     }
   }
 }
 /**
  * Instances of the class {@code ImportElementImpl} implement an {@link ImportElement}.
  */
 class ImportElementImpl extends ElementImpl implements ImportElement {
   /**
    * The library that is imported into this library by this import directive.
    */
   LibraryElement _importedLibrary;
   /**
    * The combinators that were specified as part of the import directive in the order in which they
    * were specified.
    */
   List<NamespaceCombinator> _combinators = NamespaceCombinator.EMPTY_ARRAY;
   /**
    * The prefix that was specified as part of the import directive, or {@code null} if there was no
    * prefix specified.
    */
   PrefixElement _prefix;
   /**
    * Initialize a newly created import element.
    */
   ImportElementImpl() : super.con1(null) {
   }
+  accept(ElementVisitor visitor) => visitor.visitImportElement(this);
   List<NamespaceCombinator> get combinators => _combinators;
   LibraryElement get importedLibrary => _importedLibrary;
   ElementKind get kind => ElementKind.IMPORT;
   PrefixElement get prefix => _prefix;
   /**
    * Set the combinators that were specified as part of the import directive to the given array of
    * combinators.
    * @param combinators the combinators that were specified as part of the import directive
    */
   void set combinators(List<NamespaceCombinator> combinators3) {
     this._combinators = combinators3;
   }
   /**
    * Set the library that is imported into this library by this import directive to the given
    * library.
    * @param importedLibrary the library that is imported into this library
    */
   void set importedLibrary(LibraryElement importedLibrary3) {
     this._importedLibrary = importedLibrary3;
   }
   /**
    * Set the prefix that was specified as part of the import directive to the given prefix.
    * @param prefix the prefix that was specified as part of the import directive
    */
   void set prefix(PrefixElement prefix3) {
     this._prefix = prefix3;
   }
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChild(_prefix, visitor);
+  }
   void appendTo(StringBuffer builder) {
-    builder.add("import ");
+    builder.write("import ");
     ((_importedLibrary as LibraryElementImpl)).appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code LabelElementImpl} implement a {@code LabelElement}.
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a {@code switch} statement.
    */
   bool _onSwitchStatement = false;
   /**
    * A flag indicating whether this label is associated with a {@code switch} member ({@code case}or {@code default}).
    */
   bool _onSwitchMember = false;
   /**
    * An empty array of label elements.
    */
   static List<LabelElement> EMPTY_ARRAY = new List<LabelElement>(0);
   /**
    * Initialize a newly created label element to have the given name.
    * @param name the name of this element
    * @param onSwitchStatement {@code true} if this label is associated with a {@code switch}statement
    * @param onSwitchMember {@code true} if this label is associated with a {@code switch} member
    */
   LabelElementImpl(Identifier name, bool onSwitchStatement, bool onSwitchMember) : super.con1(name) {
     this._onSwitchStatement = onSwitchStatement;
     this._onSwitchMember = onSwitchMember;
   }
-  ExecutableElement get enclosingElement => (super.enclosingElement as ExecutableElement);
+  accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
+  ExecutableElement get enclosingElement => super.enclosingElement as ExecutableElement;
   ElementKind get kind => ElementKind.LABEL;
   /**
    * Return {@code true} if this label is associated with a {@code switch} member ({@code case} or{@code default}).
    * @return {@code true} if this label is associated with a {@code switch} member
    */
   bool isOnSwitchMember() => _onSwitchMember;
   /**
    * Return {@code true} if this label is associated with a {@code switch} statement.
    * @return {@code true} if this label is associated with a {@code switch} statement
    */
@@ skipping 32 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;
   }
-  bool operator ==(Object object) => identical(this.runtimeType, object.runtimeType) && _definingCompilationUnit == ((object as LibraryElementImpl)).definingCompilationUnit;
-  ElementImpl getChild(String identifier22) {
-    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier22) {
-      return (_definingCompilationUnit as CompilationUnitElementImpl);
+  accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
+  bool operator ==(Object object) => identical(runtimeType, object.runtimeType) && _definingCompilationUnit == ((object as LibraryElementImpl)).definingCompilationUnit;
+  ElementImpl getChild(String identifier27) {
+    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier27) {
+      return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
-      if (((part as CompilationUnitElementImpl)).identifier == identifier22) {
-        return (part as CompilationUnitElementImpl);
+      if (((part as CompilationUnitElementImpl)).identifier == identifier27) {
+        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>();
     for (ExportElement element in _exports) {
@@ skipping 20 matching lines @@
     for (ImportElement element in _imports) {
       PrefixElement prefix4 = element.prefix;
       if (prefix4 != null) {
         javaSetAdd(prefixes, prefix4);
       }
     }
     return new List.from(prefixes);
   }
   int get hashCode => _definingCompilationUnit.hashCode;
   bool isBrowserApplication() => _entryPoint != null && isOrImportsBrowserLibrary();
+  bool isDartCore() => name == "dart.core";
   /**
    * Set the compilation unit that defines this library to the given compilation unit.
    * @param definingCompilationUnit the compilation unit that defines this library
    */
   void set definingCompilationUnit(CompilationUnitElement definingCompilationUnit2) {
     ((definingCompilationUnit2 as CompilationUnitElementImpl)).enclosingElement = this;
     this._definingCompilationUnit = definingCompilationUnit2;
   }
   /**
    * Set the entry point for this library to the given function.
    * @param entryPoint the entry point for this library
    */
   void set entryPoint(FunctionElement entryPoint2) {
-    ((entryPoint2 as FunctionElementImpl)).enclosingElement = this;
     this._entryPoint = entryPoint2;
   }
   /**
    * Set the specifications of all of the exports defined in this library to the given array.
    * @param exports the specifications of all of the exports defined in this library
    */
   void set exports(List<ExportElement> exports2) {
+    for (ExportElement exportElement in exports2) {
+      ((exportElement as ExportElementImpl)).enclosingElement = this;
+    }
     this._exports = exports2;
   }
   /**
    * Set the specifications of all of the imports defined in this library to the given array.
    * @param imports the specifications of all of the imports defined in this library
    */
   void set imports(List<ImportElement> imports2) {
+    for (ImportElement importElement in imports2) {
+      ((importElement as ImportElementImpl)).enclosingElement = this;
+      PrefixElementImpl prefix5 = importElement.prefix as PrefixElementImpl;
+      if (prefix5 != null) {
+        prefix5.enclosingElement = this;
+      }
+    }
     this._imports = imports2;
   }
   /**
    * Set the compilation units that are included in this library using a {@code part} directive.
    * @param parts the compilation units that are included in this library using a {@code part}directive
    */
   void set parts(List<CompilationUnitElement> parts2) {
     for (CompilationUnitElement compilationUnit in parts2) {
       ((compilationUnit as CompilationUnitElementImpl)).enclosingElement = this;
     }
     this._parts = parts2;
   }
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChild(_definingCompilationUnit, visitor);
+    safelyVisitChildren(_exports, visitor);
+    safelyVisitChildren(_imports, visitor);
+    safelyVisitChildren(_parts, visitor);
+  }
   /**
    * 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>(10);
-    Source htmlLibSource = definingCompilationUnit.source.resolve(DartSdk.DART_HTML);
+    Source htmlLibSource = definingCompilationUnit.source.resolve("dart:html");
     visited.add(this);
     for (int index = 0; index < visited.length; index++) {
       LibraryElement library = visited[index];
-      Source source8 = library.definingCompilationUnit.source;
-      if (source8 == 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);
         }
       }
     }
     return false;
   }
 }
 /**
+ * Instances of the class {@code LocalVariableElementImpl} implement a {@code LocalVariableElement}.
+ */
+class LocalVariableElementImpl extends VariableElementImpl implements LocalVariableElement {
+  /**
+   * The offset to the beginning of the visible range for this element.
+   */
+  int _visibleRangeOffset = 0;
+  /**
+   * 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.
+   * @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;
+    }
+    return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
+  }
+  /**
+   * Set the visible range for this element to the range starting at the given offset with the given
+   * length.
+   * @param offset the offset to the beginning of the visible range for this element
+   * @param length the length of the visible range for this element, or {@code -1} if this element
+   * does not have a visible range
+   */
+  void setVisibleRange(int offset, int length) {
+    _visibleRangeOffset = offset;
+    _visibleRangeLength = length;
+  }
+  void appendTo(StringBuffer builder) {
+    builder.write(type);
+    builder.write(" ");
+    builder.write(name);
+  }
+}
+/**
  * Instances of the class {@code MethodElementImpl} implement a {@code MethodElement}.
  */
 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_151_impl(name);
+    _jtd_constructor_175_impl(name);
   }
-  _jtd_constructor_151_impl(Identifier name) {
+  _jtd_constructor_175_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_152_impl(name, nameOffset);
+    _jtd_constructor_176_impl(name, nameOffset);
   }
-  _jtd_constructor_152_impl(String name, int nameOffset) {
+  _jtd_constructor_176_impl(String name, int nameOffset) {
   }
-  ClassElement get enclosingElement => (super.enclosingElement as ClassElement);
+  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
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
   /**
    * Set whether this method is static to correspond to the given value.
    * @param isStatic {@code true} if the method is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
   void appendTo(StringBuffer builder) {
-    builder.add(enclosingElement.name);
-    builder.add(".");
-    builder.add(name);
+    builder.write(enclosingElement.name);
+    builder.write(".");
+    builder.write(name);
     super.appendTo(builder);
   }
 }
 /**
  * The enumeration {@code Modifier} defines constants for all of the modifiers defined by the Dart
  * language and for a few additional flags that are useful.
  */
 class Modifier {
   static final Modifier ABSTRACT = new Modifier('ABSTRACT', 0);
   static final Modifier CONST = new Modifier('CONST', 1);
   static final Modifier FACTORY = new Modifier('FACTORY', 2);
   static final Modifier FINAL = new Modifier('FINAL', 3);
   static final Modifier GETTER = new Modifier('GETTER', 4);
   static final Modifier INITIALIZING_FORMAL = new Modifier('INITIALIZING_FORMAL', 5);
-  static final Modifier SETTER = new Modifier('SETTER', 6);
-  static final Modifier STATIC = new Modifier('STATIC', 7);
-  static final Modifier SYNTHETIC = new Modifier('SYNTHETIC', 8);
-  static final List<Modifier> values = [ABSTRACT, CONST, FACTORY, FINAL, GETTER, INITIALIZING_FORMAL, SETTER, STATIC, SYNTHETIC];
+  static final Modifier MIXIN = new Modifier('MIXIN', 6);
+  static final Modifier SETTER = new Modifier('SETTER', 7);
+  static final Modifier STATIC = new Modifier('STATIC', 8);
+  static final Modifier SYNTHETIC = new Modifier('SYNTHETIC', 9);
+  static final Modifier TYPEDEF = new Modifier('TYPEDEF', 10);
+  static final List<Modifier> values = [ABSTRACT, CONST, FACTORY, FINAL, GETTER, INITIALIZING_FORMAL, MIXIN, SETTER, STATIC, SYNTHETIC, TYPEDEF];
   final String __name;
   final int __ordinal;
   Modifier(this.__name, this.__ordinal) {
   }
   String toString() => __name;
 }
 /**
  * Instances of the class {@code MultiplyDefinedElementImpl} represent a collection of elements that
  * have the same name within the same scope.
  */
@@ skipping 13 matching lines @@
   /**
    * Initialize a newly created element to represent a list of conflicting elements.
    * @param context the analysis context in which the multiply defined elements are defined
    * @param firstElement the first element that conflicts
    * @param secondElement the second element that conflicts
    */
   MultiplyDefinedElementImpl(AnalysisContext context, Element firstElement, Element secondElement) {
     _name = firstElement.name;
     _conflictingElements = computeConflictingElements(firstElement, secondElement);
   }
+  accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
   Element getAncestor(Type elementClass) => null;
   List<Element> get conflictingElements => _conflictingElements;
   AnalysisContext get context => _context;
   Element get enclosingElement => null;
   ElementKind get kind => ElementKind.ERROR;
   LibraryElement get library => null;
   ElementLocation get location => null;
   List<Annotation> get metadata => AnnotationImpl.EMPTY_ARRAY;
   String get name => _name;
   int get nameOffset => -1;
   Source get source => null;
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in _conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
   bool isSynthetic() => true;
   String toString() {
     StringBuffer builder = new StringBuffer();
-    builder.add("[");
+    builder.write("[");
     int count = _conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.add(", ");
+        builder.write(", ");
       }
       ((_conflictingElements[i] as ElementImpl)).appendTo(builder);
     }
-    builder.add("]");
+    builder.write("]");
     return builder.toString();
   }
+  void visitChildren(ElementVisitor<Object> visitor) {
+  }
   /**
    * Add the given element to the list of elements. If the element is a multiply-defined element,
    * add all of the conflicting elements that it represents.
    * @param elements the list to which the element(s) are to be added
    * @param element the element(s) to be added
    */
   void add(List<Element> elements, Element element) {
     if (element is MultiplyDefinedElementImpl) {
       for (Element conflictingElement in ((element as MultiplyDefinedElementImpl))._conflictingElements) {
         elements.add(conflictingElement);
@@ skipping 19 matching lines @@
 }
 /**
  * Instances of the class {@code ParameterElementImpl} implement a {@code ParameterElement}.
  */
 class ParameterElementImpl extends VariableElementImpl implements ParameterElement {
   /**
    * The kind of this parameter.
    */
   ParameterKind _parameterKind;
   /**
+   * The offset to the beginning of the visible range for this element.
+   */
+  int _visibleRangeOffset = 0;
+  /**
+   * 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<ParameterElement> EMPTY_ARRAY = new List<ParameterElement>(0);
   /**
    * Initialize a newly created parameter element to have the given name.
    * @param name the name of this element
    */
   ParameterElementImpl(Identifier name) : super.con1(name) {
   }
+  accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
   ElementKind get kind => ElementKind.PARAMETER;
   ParameterKind get parameterKind => _parameterKind;
+  SourceRange get visibleRange {
+    if (_visibleRangeLength < 0) {
+      return null;
+    }
+    return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
+  }
   bool isInitializingFormal() => hasModifier(Modifier.INITIALIZING_FORMAL);
   /**
    * Set whether this parameter is an initializing formal parameter to match the given value.
    * @param isInitializingFormal {@code true} if this parameter is an initializing formal parameter
    */
   void set initializingFormal(bool isInitializingFormal) {
     setModifier(Modifier.INITIALIZING_FORMAL, isInitializingFormal);
   }
   /**
    * Set the kind of this parameter to the given kind.
    * @param parameterKind the new kind of this parameter
    */
   void set parameterKind(ParameterKind parameterKind2) {
     this._parameterKind = parameterKind2;
   }
+  /**
+   * Set the visible range for this element to the range starting at the given offset with the given
+   * length.
+   * @param offset the offset to the beginning of the visible range for this element
+   * @param length the length of the visible range for this element, or {@code -1} if this element
+   * does not have a visible range
+   */
+  void setVisibleRange(int offset, int length) {
+    _visibleRangeOffset = offset;
+    _visibleRangeLength = length;
+  }
   void appendTo(StringBuffer builder) {
-    builder.add(type);
-    builder.add(" ");
-    builder.add(name);
-    builder.add(" (");
-    builder.add(kind);
-    builder.add(")");
+    builder.write(type);
+    builder.write(" ");
+    builder.write(name);
+    builder.write(" (");
+    builder.write(kind);
+    builder.write(")");
   }
 }
 /**
  * Instances of the class {@code PrefixElementImpl} implement a {@code PrefixElement}.
  */
 class PrefixElementImpl extends ElementImpl implements PrefixElement {
   /**
    * An array containing all of the libraries that are imported using this prefix.
    */
   List<LibraryElement> _importedLibraries = LibraryElementImpl.EMPTY_ARRAY;
   /**
    * An empty array of prefix elements.
    */
   static List<PrefixElement> EMPTY_ARRAY = new List<PrefixElement>(0);
   /**
    * Initialize a newly created prefix element to have the given name.
    * @param name the name of this element
    */
   PrefixElementImpl(Identifier name) : super.con1(name) {
   }
-  LibraryElement get enclosingElement => (super.enclosingElement as LibraryElement);
+  accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
+  LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
   List<LibraryElement> get importedLibraries => _importedLibraries;
   ElementKind get kind => ElementKind.PREFIX;
   /**
    * Set the libraries that are imported using this prefix to the given libraries.
    * @param importedLibraries the libraries that are imported using this prefix
    */
   void set importedLibraries(List<LibraryElement> importedLibraries2) {
     for (LibraryElement library in importedLibraries2) {
       ((library as LibraryElementImpl)).enclosingElement = this;
     }
     this._importedLibraries = importedLibraries2;
   }
   void appendTo(StringBuffer builder) {
-    builder.add("as ");
+    builder.write("as ");
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code PropertyAccessorElementImpl} implement a{@code PropertyAccessorElement}.
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
   /**
-   * The field associated with this accessor.
+   * The variable associated with this accessor.
    */
-  FieldElement _field;
+  PropertyInducingElement _variable;
   /**
    * An empty array of property accessor elements.
    */
   static List<PropertyAccessorElement> EMPTY_ARRAY = new List<PropertyAccessorElement>(0);
   /**
-   * Initialize a newly created synthetic property accessor element to be associated with the given
-   * field.
-   * @param name the name of this element
-   */
-  PropertyAccessorElementImpl.con1(FieldElementImpl field2) : super.con2(field2.name, -1) {
-    _jtd_constructor_157_impl(field2);
-  }
-  _jtd_constructor_157_impl(FieldElementImpl field2) {
-    this._field = field2;
-    synthetic = true;
-  }
-  /**
    * Initialize a newly created property accessor element to have the given name.
    * @param name the name of this element
    */
-  PropertyAccessorElementImpl.con2(Identifier name) : super.con1(name) {
-    _jtd_constructor_158_impl(name);
+  PropertyAccessorElementImpl.con1(Identifier name) : super.con1(name) {
+    _jtd_constructor_181_impl(name);
   }
-  _jtd_constructor_158_impl(Identifier name) {
+  _jtd_constructor_181_impl(Identifier name) {
   }
-  FieldElement get field => _field;
+  /**
+   * 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_182_impl(variable2);
+  }
+  _jtd_constructor_182_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;
   }
+  PropertyInducingElement get variable => _variable;
   bool isGetter() => hasModifier(Modifier.GETTER);
   bool isSetter() => hasModifier(Modifier.SETTER);
-  /**
-   * Set the field associated with this accessor to the given field.
-   * @param field the field associated with this accessor
-   */
-  void set field(FieldElement field3) {
-    this._field = field3;
-  }
+  bool isStatic() => variable.isStatic();
   /**
    * Set whether this accessor is a getter to correspond to the given value.
    * @param isGetter {@code true} if the accessor is a getter
    */
   void set getter(bool isGetter) {
     setModifier(Modifier.GETTER, isGetter);
   }
   /**
    * Set whether this accessor is a setter to correspond to the given value.
    * @param isSetter {@code true} if the accessor is a setter
    */
   void set setter(bool isSetter) {
     setModifier(Modifier.SETTER, isSetter);
   }
+  /**
+   * Set the variable associated with this accessor to the given variable.
+   * @param variable the variable associated with this accessor
+   */
+  void set variable(PropertyInducingElement variable3) {
+    this._variable = variable3;
+  }
   void appendTo(StringBuffer builder) {
-    builder.add(isGetter() ? "get " : "set ");
-    builder.add(field.name);
+    builder.write(isGetter() ? "get " : "set ");
+    builder.write(variable.name);
     super.appendTo(builder);
   }
 }
 /**
+ * Instances of the class {@code PropertyInducingElementImpl} implement a{@code PropertyInducingElement}.
+ */
+abstract class PropertyInducingElementImpl extends VariableElementImpl implements PropertyInducingElement {
+  /**
+   * The getter associated with this element.
+   */
+  PropertyAccessorElement _getter;
+  /**
+   * The setter associated with this element, or {@code null} if the element is effectively{@code final} and therefore does not have a setter associated with it.
+   */
+  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_183_impl(name);
+  }
+  _jtd_constructor_183_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_184_impl(name);
+  }
+  _jtd_constructor_184_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;
+  }
+  /**
+   * Set the setter associated with this element to the given accessor.
+   * @param setter the setter associated with this element
+   */
+  void set setter(PropertyAccessorElement setter2) {
+    this._setter = setter2;
+  }
+}
+/**
  * Instances of the class {@code ShowCombinatorImpl} implement a {@link ShowCombinator}.
  */
 class ShowCombinatorImpl implements ShowCombinator {
   /**
    * The names that are to be made visible in the importing library if they are defined in the
    * imported library.
    */
   List<String> _shownNames = StringUtilities.EMPTY_ARRAY;
   /**
    * Initialize a newly created combinator.
    */
   ShowCombinatorImpl() : super() {
   }
   List<String> get shownNames => _shownNames;
   /**
    * Set the names that are to be made visible in the importing library if they are defined in the
    * imported library to the given names.
    * @param shownNames the names that are to be made visible in the importing library
    */
   void set shownNames(List<String> shownNames2) {
     this._shownNames = shownNames2;
   }
   String toString() {
     StringBuffer builder = new StringBuffer();
-    builder.add("show ");
+    builder.write("show ");
     int count = _shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.add(", ");
+        builder.write(", ");
       }
-      builder.add(_shownNames[i]);
+      builder.write(_shownNames[i]);
     }
     return builder.toString();
   }
 }
 /**
+ * Instances of the class {@code TopLevelVariableElementImpl} implement a{@code TopLevelVariableElement}.
+ */
+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_186_impl(name);
+  }
+  _jtd_constructor_186_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_187_impl(name);
+  }
+  _jtd_constructor_187_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}.
  */
 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) {
   }
-  ElementImpl getChild(String identifier23) {
+  accept(ElementVisitor visitor) => visitor.visitTypeAliasElement(this);
+  ElementImpl getChild(String identifier28) {
     for (VariableElement parameter in _parameters) {
-      if (((parameter as VariableElementImpl)).identifier == identifier23) {
-        return (parameter as VariableElementImpl);
+      if (((parameter as VariableElementImpl)).identifier == identifier28) {
+        return parameter as VariableElementImpl;
       }
     }
     for (TypeVariableElement typeVariable in _typeVariables) {
-      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier23) {
-        return (typeVariable as TypeVariableElementImpl);
+      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier28) {
+        return typeVariable as TypeVariableElementImpl;
       }
     }
     return null;
   }
-  CompilationUnitElement get enclosingElement => (super.enclosingElement as CompilationUnitElement);
+  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 type7) {
-    this._type = type7;
+  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(StringBuffer builder) {
-    builder.add("typedef ");
-    builder.add(name);
+    builder.write("typedef ");
+    builder.write(name);
     int variableCount = _typeVariables.length;
     if (variableCount > 0) {
-      builder.add("<");
+      builder.write("<");
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
-          builder.add(", ");
+          builder.write(", ");
         }
         ((_typeVariables[i] as TypeVariableElementImpl)).appendTo(builder);
       }
-      builder.add(">");
+      builder.write(">");
     }
-    builder.add("(");
+    builder.write("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.add(", ");
+        builder.write(", ");
       }
       ((_parameters[i] as ParameterElementImpl)).appendTo(builder);
     }
-    builder.add(")");
+    builder.write(")");
     if (_type != null) {
-      builder.add(" -> ");
-      builder.add(_type.returnType);
+      builder.write(" -> ");
+      builder.write(_type.returnType);
     }
   }
 }
 /**
  * Instances of the class {@code TypeVariableElementImpl} implement a {@code TypeVariableElement}.
  */
 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
    * does not have an explicit bound.
    */
   Type2 _bound;
   /**
    * An empty array of type variable elements.
    */
   static List<TypeVariableElement> EMPTY_ARRAY = new List<TypeVariableElement>(0);
   /**
    * Initialize a newly created type variable element to have the given name.
    * @param name the name of this element
    */
   TypeVariableElementImpl(Identifier name) : super.con1(name) {
   }
+  accept(ElementVisitor visitor) => visitor.visitTypeVariableElement(this);
   Type2 get bound => _bound;
   ElementKind get kind => ElementKind.TYPE_VARIABLE;
   TypeVariableType get type => _type;
   /**
    * Set the type representing the bound associated with this variable to the given type.
    * @param bound the type representing the bound associated with this variable
    */
   void set bound(Type2 bound2) {
     this._bound = bound2;
   }
   /**
    * Set the type defined by this type variable to the given type
    * @param type the type defined by this type variable
    */
-  void set type(TypeVariableType type8) {
-    this._type = type8;
+  void set type(TypeVariableType type9) {
+    this._type = type9;
   }
   void appendTo(StringBuffer builder) {
-    builder.add(name);
+    builder.write(name);
     if (_bound != null) {
-      builder.add(" extends ");
-      builder.add(_bound);
+      builder.write(" extends ");
+      builder.write(_bound);
     }
   }
 }
 /**
  * Instances of the class {@code VariableElementImpl} implement a {@code VariableElement}.
  */
-class VariableElementImpl extends ElementImpl implements VariableElement {
+abstract class VariableElementImpl extends ElementImpl implements VariableElement {
   /**
    * The declared type of this variable.
    */
   Type2 _type;
   /**
    * A synthetic function representing this variable's initializer, or {@code null} if this variable
    * does not have an initializer.
    */
   FunctionElement _initializer;
   /**
-   * The offset to the beginning of the visible range for this element.
-   */
-  int _visibleRangeOffset = 0;
-  /**
-   * 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 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_162_impl(name);
+    _jtd_constructor_190_impl(name);
   }
-  _jtd_constructor_162_impl(Identifier name) {
+  _jtd_constructor_190_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_163_impl(name, nameOffset);
+    _jtd_constructor_191_impl(name, nameOffset);
   }
-  _jtd_constructor_163_impl(String name, int nameOffset) {
+  _jtd_constructor_191_impl(String name, int nameOffset) {
   }
   FunctionElement get initializer => _initializer;
-  ElementKind get kind => ElementKind.VARIABLE;
   Type2 get type => _type;
-  SourceRange get visibleRange {
-    if (_visibleRangeLength < 0) {
-      return null;
-    }
-    return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
-  }
   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) {
     setModifier(Modifier.CONST, isConst);
   }
   /**
@@ skipping 10 matching lines @@
   void set initializer(FunctionElement initializer3) {
     if (initializer3 != null) {
       ((initializer3 as FunctionElementImpl)).enclosingElement = this;
     }
     this._initializer = initializer3;
   }
   /**
    * Set the declared type of this variable to the given type.
    * @param type the declared type of this variable
    */
-  void set type(Type2 type9) {
-    this._type = type9;
+  void set type(Type2 type10) {
+    this._type = type10;
   }
-  /**
-   * Set the visible range for this element to the range starting at the given offset with the given
-   * length.
-   * @param offset the offset to the beginning of the visible range for this element
-   * @param length the length of the visible range for this element, or {@code -1} if this element
-   * does not have a visible range
-   */
-  void setVisibleRange(int offset, int length) {
-    _visibleRangeOffset = offset;
-    _visibleRangeLength = length;
+  void visitChildren(ElementVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChild(_initializer, visitor);
   }
   void appendTo(StringBuffer builder) {
-    builder.add(type);
-    builder.add(" ");
-    builder.add(name);
+    builder.write(type);
+    builder.write(" ");
+    builder.write(name);
   }
 }
 /**
  * The unique instance of the class {@code BottomTypeImpl} implements the type {@code bottom}.
  */
 class BottomTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static BottomTypeImpl _INSTANCE = new BottomTypeImpl();
@@ skipping 26 matching lines @@
    * @return the unique instance of this class
    */
   static DynamicTypeImpl get instance => _INSTANCE;
   /**
    * Prevent the creation of instances of this class.
    */
   DynamicTypeImpl() : super(new DynamicElementImpl(), Keyword.DYNAMIC.syntax) {
     ((element as DynamicElementImpl)).type = this;
   }
   bool operator ==(Object object) => object is DynamicTypeImpl;
+  bool isDynamic() => true;
   bool isMoreSpecificThan(Type2 type) => false;
-  bool isSubtypeOf(Type2 type) => false;
+  bool isSubtypeOf(Type2 type) => identical(this, type);
   bool isSupertypeOf(Type2 type) => true;
   DynamicTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 }
 /**
  * Instances of the class {@code FunctionTypeImpl} defines the behavior common to objects
  * representing the type of a function, method, constructor, getter, or setter.
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
-   * Return {@code true} if all of the types in the first array are equal to the corresponding types
-   * in the second array.
-   * @param firstTypes the first array of types being compared
-   * @param secondTypes the second array of types being compared
-   * @return {@code true} if all of the types in the first array are equal to the corresponding
-   * types in the second array
+   * Return {@code true} if all of the name/type pairs in the first map are equal to the
+   * corresponding name/type pairs in the second map. The maps are expected to iterate over their
+   * entries in the same order in which those entries were added to the map.
+   * @param firstTypes the first map of name/type pairs being compared
+   * @param secondTypes the second map of name/type pairs being compared
+   * @return {@code true} if all of the name/type pairs in the first map are equal to the
+   * corresponding name/type pairs in the second map
    */
-  static bool equals2(LinkedHashMap<String, Type2> firstTypes, LinkedHashMap<String, Type2> secondTypes) {
+  static bool equals2(Map<String, Type2> firstTypes, Map<String, Type2> secondTypes) {
     if (secondTypes.length != firstTypes.length) {
       return false;
     }
     JavaIterator<MapEntry<String, Type2>> firstIterator = new JavaIterator(getMapEntrySet(firstTypes));
     JavaIterator<MapEntry<String, Type2>> secondIterator = new JavaIterator(getMapEntrySet(firstTypes));
     while (firstIterator.hasNext) {
       MapEntry<String, Type2> firstEntry = firstIterator.next();
       MapEntry<String, Type2> secondEntry = secondIterator.next();
       if (firstEntry.getKey() != secondEntry.getKey() || firstEntry.getValue() != secondEntry.getValue()) {
         return false;
       }
     }
     return true;
   }
   /**
    * Return a map containing the results of using the given argument types and parameter types to
    * perform a substitution on all of the values in the given map. The order of the entries will be
    * preserved.
    * @param types the types on which a substitution is to be performed
    * @param argumentTypes the argument types for the substitution
    * @param parameterTypes the parameter types for the substitution
    * @return the result of performing the substitution on each of the types
    */
-  static LinkedHashMap<String, Type2> substitute3(LinkedHashMap<String, Type2> types, List<Type2> argumentTypes, List<Type2> parameterTypes) {
+  static Map<String, Type2> substitute3(Map<String, Type2> types, List<Type2> argumentTypes, List<Type2> parameterTypes) {
+    if (types.isEmpty) {
+      return types;
+    }
     LinkedHashMap<String, Type2> newTypes = new LinkedHashMap<String, Type2>();
     for (MapEntry<String, Type2> entry in getMapEntrySet(types)) {
       newTypes[entry.getKey()] = entry.getValue().substitute2(argumentTypes, parameterTypes);
     }
     return newTypes;
   }
   /**
    * An array containing the actual types of the type arguments.
    */
   List<Type2> _typeArguments = TypeImpl.EMPTY_ARRAY;
   /**
    * An array containing the types of the normal parameters of this type of function. The parameter
    * types are in the same order as they appear in the declaration of the function.
    * @return the types of the normal parameters of this type of function
    */
   List<Type2> _normalParameterTypes = TypeImpl.EMPTY_ARRAY;
   /**
    * A table mapping the names of optional (positional) parameters to the types of the optional
    * parameters of this type of function.
    */
   List<Type2> _optionalParameterTypes = TypeImpl.EMPTY_ARRAY;
   /**
    * A table mapping the names of named parameters to the types of the named parameters of this type
    * of function.
    */
-  LinkedHashMap<String, Type2> _namedParameterTypes = new LinkedHashMap<String, Type2>();
+  Map<String, Type2> _namedParameterTypes = new Map();
   /**
    * 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_209_impl(element);
+    _jtd_constructor_242_impl(element);
   }
-  _jtd_constructor_209_impl(ExecutableElement element) {
+  _jtd_constructor_242_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_210_impl(element);
+    _jtd_constructor_243_impl(element);
   }
-  _jtd_constructor_210_impl(TypeAliasElement element) {
+  _jtd_constructor_243_impl(TypeAliasElement element) {
   }
   bool operator ==(Object object) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
-    FunctionTypeImpl otherType = (object as FunctionTypeImpl);
+    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 element34 = element;
-    if (element34 == null) {
+    Element element37 = element;
+    if (element37 == null) {
       return 0;
     }
-    return element34.hashCode;
+    return element37.hashCode;
   }
   bool isSubtypeOf(Type2 type) {
-    if (type == null || type is! FunctionType) {
+    if (type == null) {
       return false;
-    } else if (identical(this, type) || this == type) {
+    } else if (identical(this, type) || type.isDynamic() || type.isDartCoreFunction()) {
+      return true;
+    } else if (type is! FunctionType) {
+      return false;
+    } else if (this == type) {
       return true;
     }
     FunctionType t = this;
-    FunctionType s = (type as FunctionType);
+    FunctionType s = type as FunctionType;
     if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
       return false;
     } else if (t.normalParameterTypes.length > 0) {
       List<Type2> tTypes = t.normalParameterTypes;
       List<Type2> sTypes = s.normalParameterTypes;
       for (int i = 0; i < tTypes.length; i++) {
         if (!tTypes[i].isAssignableTo(sTypes[i])) {
           return false;
         }
       }
@@ skipping 77 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 element35 = element;
-    FunctionTypeImpl newType = (element35 is ExecutableElement) ? new FunctionTypeImpl.con1((element35 as ExecutableElement)) : new FunctionTypeImpl.con2((element35 as TypeAliasElement));
+    Element element38 = element;
+    FunctionTypeImpl newType = (element38 is ExecutableElement) ? new FunctionTypeImpl.con1((element38 as ExecutableElement)) : new FunctionTypeImpl.con2((element38 as TypeAliasElement));
     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);
+    newType._namedParameterTypes = substitute3(_namedParameterTypes, argumentTypes, parameterTypes);
     return newType;
   }
   void appendTo(StringBuffer builder) {
-    builder.add("(");
+    builder.write("(");
     bool needsComma = false;
     if (_normalParameterTypes.length > 0) {
       for (Type2 type in _normalParameterTypes) {
         if (needsComma) {
-          builder.add(", ");
+          builder.write(", ");
         } else {
           needsComma = true;
         }
         ((type as TypeImpl)).appendTo(builder);
       }
     }
     if (_optionalParameterTypes.length > 0) {
       if (needsComma) {
-        builder.add(", ");
+        builder.write(", ");
         needsComma = false;
       }
-      builder.add("[");
+      builder.write("[");
       for (Type2 type in _optionalParameterTypes) {
         if (needsComma) {
-          builder.add(", ");
+          builder.write(", ");
         } else {
           needsComma = true;
         }
         ((type as TypeImpl)).appendTo(builder);
       }
-      builder.add("]");
+      builder.write("]");
       needsComma = true;
     }
     if (_namedParameterTypes.length > 0) {
       if (needsComma) {
-        builder.add(", ");
+        builder.write(", ");
         needsComma = false;
       }
-      builder.add("{");
+      builder.write("{");
       for (MapEntry<String, Type2> entry in getMapEntrySet(_namedParameterTypes)) {
         if (needsComma) {
-          builder.add(", ");
+          builder.write(", ");
         } else {
           needsComma = true;
         }
-        builder.add(entry.getKey());
-        builder.add(": ");
+        builder.write(entry.getKey());
+        builder.write(": ");
         ((entry.getValue() as TypeImpl)).appendTo(builder);
       }
-      builder.add("}");
+      builder.write("}");
       needsComma = true;
     }
-    builder.add(") -> ");
-    ((_returnType as TypeImpl)).appendTo(builder);
+    builder.write(") -> ");
+    if (_returnType == null) {
+      builder.write("null");
+    } else {
+      ((_returnType as TypeImpl)).appendTo(builder);
+    }
   }
 }
 /**
  * Instances of the class {@code InterfaceTypeImpl} defines the behavior common to objects
  * representing the type introduced by either a class or an interface, or a reference to such a
  * type.
  */
 class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   /**
    * An empty array of types.
@@ skipping 50 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 element36 = type.element;
-    if (element36 != null && element36 is ClassElement) {
-      ClassElement classElement = (element36 as ClassElement);
+    Element element39 = type.element;
+    if (element39 != null && element39 is ClassElement) {
+      ClassElement classElement = element39 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_211_impl(element);
+    _jtd_constructor_244_impl(element);
   }
-  _jtd_constructor_211_impl(ClassElement element) {
+  _jtd_constructor_244_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_212_impl(name);
+    _jtd_constructor_245_impl(name);
   }
-  _jtd_constructor_212_impl(String name) {
+  _jtd_constructor_245_impl(String name) {
   }
   bool operator ==(Object object) {
     if (object is! InterfaceTypeImpl) {
       return false;
     }
-    InterfaceTypeImpl otherType = (object as InterfaceTypeImpl);
+    InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return element == otherType.element && JavaArrays.equals(_typeArguments, otherType._typeArguments);
   }
-  ClassElement get element => (super.element as ClassElement);
+  ClassElement get element => super.element as ClassElement;
   Type2 getLeastUpperBound(Type2 type) {
     Type2 dynamicType = DynamicTypeImpl.instance;
     if (identical(this, dynamicType) || identical(type, dynamicType)) {
       return dynamicType;
     }
     if (type == null || type is! InterfaceType) {
       return null;
     }
     InterfaceType i = this;
-    InterfaceType j = (type as InterfaceType);
+    InterfaceType j = type as InterfaceType;
     Set<InterfaceType> si = computeSuperinterfaceSet(i);
     Set<InterfaceType> sj = computeSuperinterfaceSet(j);
     javaSetAdd(si, i);
     javaSetAdd(sj, j);
     si.retainAll(sj);
     Set<InterfaceType> s = si;
     List<InterfaceType> sn = new List.from(s);
-    List<int> depths = new List<int>(sn.length);
+    List<int> depths = new List<int>.filled(sn.length, 0);
     int maxDepth = 0;
     for (int n = 0; n < sn.length; n++) {
       depths[n] = computeLongestInheritancePathToObject(sn[n]);
       if (depths[n] > maxDepth) {
         maxDepth = depths[n];
       }
     }
     for (; maxDepth >= 0; maxDepth--) {
       int indexOfLeastUpperBound = -1;
       int numberOfTypesAtMaxDepth = 0;
       for (int m = 0; m < depths.length; m++) {
         if (depths[m] == maxDepth) {
           numberOfTypesAtMaxDepth++;
           indexOfLeastUpperBound = m;
         }
       }
       if (numberOfTypesAtMaxDepth == 1) {
         return sn[indexOfLeastUpperBound];
       }
     }
     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 element37 = element;
-    if (element37 == null) {
+    ClassElement element40 = element;
+    if (element40 == null) {
       return 0;
     }
-    return element37.hashCode;
+    return element40.hashCode;
+  }
+  bool isDartCoreFunction() {
+    ClassElement element41 = element;
+    if (element41 == null) {
+      return false;
+    }
+    return element41.name == "Function" && element41.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 10 matching lines @@
       }
     }
     return false;
   }
   bool isMoreSpecificThan(Type2 type) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
-    InterfaceType s = (type as InterfaceType);
+    InterfaceType s = type as InterfaceType;
     if (this == s) {
       return true;
     }
     if (s.isDirectSupertypeOf(this)) {
       return true;
     }
     ClassElement tElement = element;
     ClassElement sElement = s.element;
     if (tElement == sElement) {
       List<Type2> tArguments = typeArguments;
@@ skipping 17 matching lines @@
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is TypeVariableType) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     } else if (this == type) {
       return true;
     }
     InterfaceType typeT = this;
-    InterfaceType typeS = (type as InterfaceType);
+    InterfaceType typeS = type as InterfaceType;
     ClassElement elementT = element;
     if (elementT == null) {
       return false;
     }
     typeT = substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(elementT.typeVariables));
     if (typeT == typeS) {
       return true;
     } else if (elementT == typeS.element) {
       List<Type2> typeTArgs = typeT.typeArguments;
       List<Type2> typeSArgs = typeS.typeArguments;
@@ skipping 38 matching lines @@
       throw new IllegalArgumentException("argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0) {
       return this;
     }
     InterfaceTypeImpl newType = new InterfaceTypeImpl.con1(element);
     newType.typeArguments = TypeImpl.substitute(_typeArguments, argumentTypes, parameterTypes);
     return newType;
   }
   void appendTo(StringBuffer builder) {
-    builder.add(name);
+    builder.write(name);
     int argumentCount = _typeArguments.length;
     if (argumentCount > 0) {
-      builder.add("<");
+      builder.write("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
-          builder.add(", ");
+          builder.write(", ");
         }
         ((_typeArguments[i] as TypeImpl)).appendTo(builder);
       }
-      builder.add(">");
+      builder.write(">");
     }
   }
 }
 /**
  * The abstract class {@code TypeImpl} implements the behavior common to objects representing the
  * declared type of elements in the element model.
  */
 abstract class TypeImpl implements Type2 {
   /**
    * Return an array containing the results of using the given argument types and parameter types to
    * perform a substitution on all of the given types.
    * @param types the types on which a substitution is to be performed
    * @param argumentTypes the argument types for the substitution
    * @param parameterTypes the parameter types for the substitution
    * @return the result of performing the substitution on each of the types
    */
   static List<Type2> substitute(List<Type2> types, List<Type2> argumentTypes, List<Type2> parameterTypes) {
     int length6 = types.length;
+    if (length6 == 0) {
+      return types;
+    }
     List<Type2> newTypes = new List<Type2>(length6);
     for (int i = 0; i < length6; i++) {
       newTypes[i] = types[i].substitute2(argumentTypes, parameterTypes);
     }
     return newTypes;
   }
   /**
    * The element representing the declaration of this type, or {@code null} if the type has not, or
    * cannot, be associated with an element.
    */
@@ skipping 12 matching lines @@
    * @param name the name of the type
    */
   TypeImpl(Element element, String name) {
     this._element = element;
     this._name = name;
   }
   Element get element => _element;
   Type2 getLeastUpperBound(Type2 type) => null;
   String get name => _name;
   bool isAssignableTo(Type2 type) => this.isSubtypeOf(type) || type.isSubtypeOf(this);
+  bool isDartCoreFunction() => false;
+  bool isDynamic() => false;
   bool isMoreSpecificThan(Type2 type) => false;
   bool isSupertypeOf(Type2 type) => type.isSubtypeOf(this);
+  bool isVoid() => false;
   String toString() {
     StringBuffer builder = new StringBuffer();
     appendTo(builder);
     return builder.toString();
   }
   /**
    * Append a textual representation of this type to the given builder.
    * @param builder the builder to which the text is to be appended
    */
   void appendTo(StringBuffer builder) {
     if (_name == null) {
-      builder.add("<unnamed type>");
+      builder.write("<unnamed type>");
     } else {
-      builder.add(_name);
+      builder.write(_name);
     }
   }
 }
 /**
  * Instances of the class {@code TypeVariableTypeImpl} defines the behavior of objects representing
  * the type introduced by a type variable.
  */
 class TypeVariableTypeImpl extends TypeImpl implements TypeVariableType {
   /**
    * Return an array containing the type variable types defined by the given array of type variable
@@ skipping 10 matching lines @@
     return types;
   }
   /**
    * Initialize a newly created type variable to be declared by the given element and to have the
    * given name.
    * @param element the element representing the declaration of the type variable
    */
   TypeVariableTypeImpl(TypeVariableElement element) : super(element, element.name) {
   }
   bool operator ==(Object object) => object is TypeVariableTypeImpl && element == ((object as TypeVariableTypeImpl)).element;
-  TypeVariableElement get element => (super.element as TypeVariableElement);
+  TypeVariableElement get element => super.element as TypeVariableElement;
   int get hashCode => element.hashCode;
   bool isMoreSpecificThan(Type2 type) {
     Type2 upperBound = element.bound;
     return type == upperBound;
   }
   bool isSubtypeOf(Type2 type) => true;
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     int length7 = parameterTypes.length;
     for (int i = 0; i < length7; i++) {
       if (parameterTypes[i] == this) {
@@ skipping 16 matching lines @@
    * @return the unique instance of this class
    */
   static VoidTypeImpl get instance => _INSTANCE;
   /**
    * Prevent the creation of instances of this class.
    */
   VoidTypeImpl() : super(null, Keyword.VOID.syntax) {
   }
   bool operator ==(Object object) => identical(object, this);
   bool isSubtypeOf(Type2 type) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
+  bool isVoid() => true;
   VoidTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 }
 /**
  * The interface {@code FunctionType} defines the behavior common to objects representing the type
  * of a function, method, constructor, getter, or setter. Function types come in three variations:
  * <ol>
  * <li>The types of functions that only have required parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T</i>.</li>
  * <li>The types of functions with optional positional parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [T<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>]) &rarr;
@@ skipping 231 matching lines @@
   String get name;
   /**
    * Return {@code true} if this type is assignable to the given type. A type <i>T</i> may be
    * assigned to a type <i>S</i>, written <i>T</i> &hArr; <i>S</i>, iff either <i>T</i> <: <i>S</i>
    * or <i>S</i> <: <i>T</i>.
    * @param type the type being compared with this type
    * @return {@code true} if this type is assignable to the given type
    */
   bool isAssignableTo(Type2 type);
   /**
+   * Return {@code true} if this type represents the type 'Function' defined in the dart:core
+   * library.
+   * @return {@code true} if this type represents the type 'Function' defined in the dart:core
+   * library
+   */
+  bool isDartCoreFunction();
+  /**
+   * Return {@code true} if this type represents the type 'dynamic'.
+   * @return {@code true} if this type represents the type 'dynamic'
+   */
+  bool isDynamic();
+  /**
    * Return {@code true} if this type is more specific than the given type.
    * @param type the type being compared with this type
    * @return {@code true} if this type is more specific than the given type
    */
   bool isMoreSpecificThan(Type2 type);
   /**
    * Return {@code true} if this type is a subtype of the given type.
    * @param type the type being compared with this type
    * @return {@code true} if this type is a subtype of the given type
    */
   bool isSubtypeOf(Type2 type);
   /**
    * Return {@code true} if this type is a supertype of the given type. A type <i>S</i> is a
    * supertype of <i>T</i>, written <i>S</i> :> <i>T</i>, iff <i>T</i> is a subtype of <i>S</i>.
    * @param type the type being compared with this type
    * @return {@code true} if this type is a supertype of the given type
    */
   bool isSupertypeOf(Type2 type);
   /**
+   * Return {@code true} if this type represents the type 'void'.
+   * @return {@code true} if this type represents the type 'void'
+   */
+  bool isVoid();
+  /**
    * Return the type resulting from substituting the given arguments for the given parameters in
    * this type. The specification defines this operation in section 2: <blockquote> The notation
    * <i>[x<sub>1</sub>, ..., x<sub>n</sub>/y<sub>1</sub>, ..., y<sub>n</sub>]E</i> denotes a copy of
    * <i>E</i> in which all occurrences of <i>y<sub>i</sub>, 1 <= i <= n</i> have been replaced with
    * <i>x<sub>i</sub></i>.</blockquote> Note that, contrary to the specification, this method will
    * not create a copy of this type if no substitutions were required, but will return this type
    * directly.
    * @param argumentTypes the actual type arguments being substituted for the parameters
    * @param parameterTypes the parameters to be replaced
    * @return the result of performing the substitution
    */
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }
 /**
  * The interface {@code TypeVariableType} defines the behavior of objects representing the type
  * introduced by a type variable.
  */
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
-}
+}