New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/element.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
@@ skipping 105 matching lines @@
    * 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 executable element representing the method, getter or setter that results from
+   * looking up the given member in this class with respect to the given library, or {@code null} if
+   * the look up fails. This method is used to determine what member the passed name is inherited
+   * from. The behavior of this method is defined by the Dart Language Specification in section
+   * 8.1.1: Let <i>C</i> be a class declared in library <i>L</i> with superclass <i>S</i> and let
+   * <i>C</i> declare an instance member <i>m</i>, and assume <i>S</i> declares an instance member
+   * </i>m'</i> with the same name as m. Then <i>m</i> overrides m'</i> iff <i>m'</i> is accessible
+   * to <i>L</i>, <i>m</i> has the same name as <i>m'</i> and neither <i>m</i> nor <i>m'</i> are
+   * fields.
+   * @param memberName the name of the member being looked up
+   * @param library the library with respect to which the lookup is being performed
+   * @return the result of looking up the given member in this class with respect to the given
+   * library
+   */
+  ExecutableElement lookUpExecutable(String memberName, LibraryElement library);
+  /**
    * 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>
    * 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>.
@@ skipping 140 matching lines @@
    * 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 documentation comment for this element as it appears in the original source
+   * (complete with the beginning and ending delimiters), or {@code null} if this element does not
+   * have a documentation comment associated with it. This can be a long-running operation if the
+   * information needed to access the comment is not cached.
+   * @return this element's documentation comment
+   * @throws AnalysisException if the documentation comment could not be determined because the
+   * analysis could not be performed
+   */
+  String computeDocumentationComment();
+  /**
    * 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 94 matching lines @@
   static final ElementKind PREFIX = new ElementKind('PREFIX', 19, "import prefix");
   static final ElementKind SETTER = new ElementKind('SETTER', 20, "setter");
   static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 21, "top level variable");
   static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 22, "function type alias");
   static final ElementKind TYPE_VARIABLE = new ElementKind('TYPE_VARIABLE', 23, "type variable");
   static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 24, "<universe>");
   static final List<ElementKind> values = [CLASS, COMPILATION_UNIT, CONSTRUCTOR, DYNAMIC, EMBEDDED_HTML_SCRIPT, ERROR, EXPORT, EXTERNAL_HTML_SCRIPT, FIELD, FUNCTION, GETTER, HTML, IMPORT, LABEL, LIBRARY, LOCAL_VARIABLE, METHOD, NAME, PARAMETER, PREFIX, SETTER, TOP_LEVEL_VARIABLE, FUNCTION_TYPE_ALIAS, TYPE_VARIABLE, UNIVERSE];
   final String __name;
   final int __ordinal;
   int get ordinal => __ordinal;
+  /**
+   * Return the kind of the given element, or {@link #ERROR} if the element is {@code null}. This is
+   * a utility method that can reduce the need for null checks in other places.
+   * @param element the element whose kind is to be returned
+   * @return the kind of the given element
+   */
+  static ElementKind of(Element element) {
+    if (element == null) {
+      return ERROR;
+    }
+    return element.kind;
+  }
+  /**
+   * The name displayed in the UI for this kind of element.
+   */
   String _displayName;
+  /**
+   * Initialize a newly created element kind to have the given display name.
+   * @param displayName the name displayed in the UI for this kind of element
+   */
   ElementKind(this.__name, this.__ordinal, String displayName) {
     this._displayName = displayName;
   }
   /**
+   * Return the name displayed in the UI for this kind of element.
    * @return the name of this {@link ElementKind} to display in UI.
    */
   String get displayName => _displayName;
   int compareTo(ElementKind other) => __ordinal - other.__ordinal;
   String toString() => __name;
 }
 /**
  * The interface {@code ElementLocation} defines the behavior of objects that represent the location
  * of an element within the element model.
  * @coverage dart.engine.element
@@ skipping 932 matching lines @@
     }
     for (TypeVariableElement typeVariable in _typeVariables) {
       if (((typeVariable as TypeVariableElementImpl)).identifier == identifier2) {
         return typeVariable as TypeVariableElementImpl;
       }
     }
     return null;
   }
   List<ConstructorElement> get constructors => _constructors;
   /**
+   * Return the executable elemement representing the getter, setter or method with the given name
+   * that is declared in this class, or {@code null} if this class does not declare a member with
+   * the given name.
+   * @param memberName the name of the getter to be returned
+   * @return the member declared in this class with the given name
+   */
+  ExecutableElement getExecutable(String memberName) {
+    for (PropertyAccessorElement accessor in _accessors) {
+      if (accessor.name == memberName) {
+        return accessor;
+      }
+    }
+    return getMethod(memberName);
+  }
+  /**
    * Given some name, this returns the {@link FieldElement} with the matching name, if there is no
    * such field, then {@code null} is returned.
    * @param name some name to lookup a field element with
    * @return the matching field element, or {@code null} if no such element was found
    */
   FieldElement getField(String name2) {
     for (FieldElement fieldElement in _fields) {
       if (name2 == fieldElement.name) {
         return fieldElement;
       }
@@ skipping 64 matching lines @@
       String name2 = element.name;
       if (name2 == null || name2.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);
+  ExecutableElement lookUpExecutable(String memberName, LibraryElement library) {
+    ExecutableElement element = getExecutable(memberName);
     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);
+        ClassElementImpl mixinElementImpl = mixinElement as ClassElementImpl;
+        element = mixinElementImpl.getExecutable(memberName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
     }
     if (_supertype != null) {
       ClassElement supertypeElement = _supertype.element;
       if (supertypeElement != null) {
-        element = supertypeElement.lookUpGetter(getterName, library);
+        return supertypeElement.lookUpExecutable(memberName, library);
+      }
+    }
+    return null;
+  }
+  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)) {
           return element;
         }
       }
     }
+    if (_supertype != null) {
+      ClassElement supertypeElement = _supertype.element;
+      if (supertypeElement != null) {
+        return supertypeElement.lookUpGetter(getterName, library);
+      }
+    }
     return null;
   }
   MethodElement lookUpMethod(String methodName, LibraryElement library) {
     MethodElement element = getMethod(methodName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     for (InterfaceType mixin in _mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         element = ((mixinElement as ClassElementImpl)).getMethod(methodName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
     }
     if (_supertype != null) {
       ClassElement supertypeElement = _supertype.element;
       if (supertypeElement != null) {
-        element = supertypeElement.lookUpMethod(methodName, library);
-        if (element != null && element.isAccessibleIn(library)) {
-          return element;
-        }
+        return supertypeElement.lookUpMethod(methodName, library);
       }
     }
     return null;
   }
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
     PropertyAccessorElement element = getSetter(setterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     for (InterfaceType mixin in _mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         element = ((mixinElement as ClassElementImpl)).getSetter(setterName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
     }
     if (_supertype != null) {
       ClassElement supertypeElement = _supertype.element;
       if (supertypeElement != null) {
-        element = supertypeElement.lookUpSetter(setterName, library);
-        if (element != null && element.isAccessibleIn(library)) {
-          return element;
-        }
+        return supertypeElement.lookUpSetter(setterName, library);
       }
     }
     return null;
   }
   /**
    * Set whether this class is abstract to correspond to the given value.
    * @param isAbstract {@code true} if the class is abstract
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
@@ skipping 492 matching lines @@
   List<Annotation> _metadata = AnnotationImpl.EMPTY_ARRAY;
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode = 0;
   /**
    * Initialize a newly created element to have the given name.
    * @param name the name of this element
    */
   ElementImpl.con1(Identifier name2) {
-    _jtd_constructor_188_impl(name2);
+    _jtd_constructor_189_impl(name2);
   }
-  _jtd_constructor_188_impl(Identifier name2) {
-    _jtd_constructor_189_impl(name2 == null ? "" : name2.name, name2 == null ? -1 : name2.offset);
+  _jtd_constructor_189_impl(Identifier name2) {
+    _jtd_constructor_190_impl(name2 == null ? "" : name2.name, name2 == null ? -1 : name2.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 name2, int nameOffset2) {
-    _jtd_constructor_189_impl(name2, nameOffset2);
+    _jtd_constructor_190_impl(name2, nameOffset2);
   }
-  _jtd_constructor_189_impl(String name2, int nameOffset2) {
+  _jtd_constructor_190_impl(String name2, int nameOffset2) {
     this._name = StringUtilities.intern(name2);
     this._nameOffset = nameOffset2;
   }
+  String computeDocumentationComment() {
+    AnalysisContext context2 = context;
+    if (context2 == null) {
+      return null;
+    }
+    return context2.computeDocumentationComment(this);
+  }
   bool operator ==(Object object) => object != null && 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 the child of this element that is uniquely identified by the given identifier, or{@code null} if there is no such child.
@@ skipping 149 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_190_impl(element);
+    _jtd_constructor_191_impl(element);
   }
-  _jtd_constructor_190_impl(Element element) {
+  _jtd_constructor_191_impl(Element element) {
     List<String> components = new List<String>();
     Element ancestor = element;
     while (ancestor != null) {
       components.insert(0, ((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_191_impl(encoding);
+    _jtd_constructor_192_impl(encoding);
   }
-  _jtd_constructor_191_impl(String encoding) {
+  _jtd_constructor_192_impl(String encoding) {
     this._components = decode(encoding);
   }
   bool operator ==(Object object) {
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
     return JavaArrays.equals(_components, location._components);
   }
   /**
@@ skipping 118 matching lines @@
   FunctionType _type;
   /**
    * An empty array of executable elements.
    */
   static List<ExecutableElement> EMPTY_ARRAY = new List<ExecutableElement>(0);
   /**
    * Initialize a newly created executable element to have the given name.
    * @param name the name of this element
    */
   ExecutableElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_193_impl(name);
+    _jtd_constructor_194_impl(name);
   }
-  _jtd_constructor_193_impl(Identifier name) {
+  _jtd_constructor_194_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_194_impl(name, nameOffset);
+    _jtd_constructor_195_impl(name, nameOffset);
   }
-  _jtd_constructor_194_impl(String name, int nameOffset) {
+  _jtd_constructor_195_impl(String name, int nameOffset) {
   }
   ElementImpl getChild(String identifier2) {
     for (ExecutableElement function in _functions) {
       if (((function as ExecutableElementImpl)).identifier == identifier2) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
       if (((label as LabelElementImpl)).identifier == identifier2) {
         return label as LabelElementImpl;
@@ skipping 123 matching lines @@
    * library.
    * @param exportedLibrary the library that is exported from this library
    */
   void set exportedLibrary(LibraryElement exportedLibrary2) {
     this._exportedLibrary = exportedLibrary2;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("export ");
     ((_exportedLibrary as LibraryElementImpl)).appendTo(builder);
   }
+  String get identifier => _exportedLibrary.name;
 }
 /**
  * Instances of the class {@code ExternalHtmlScriptElementImpl} implement an{@link ExternalHtmlScriptElement}.
  * @coverage dart.engine.element
  */
 class ExternalHtmlScriptElementImpl extends HtmlScriptElementImpl implements ExternalHtmlScriptElement {
   /**
    * The source specified in the {@code source} attribute or {@code null} if unspecified.
    */
   Source _scriptSource;
@@ skipping 21 matching lines @@
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
   /**
    * An empty array of field elements.
    */
   static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);
   /**
    * Initialize a newly created field element to have the given name.
    * @param name the name of this element
    */
   FieldElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_197_impl(name);
+    _jtd_constructor_198_impl(name);
   }
-  _jtd_constructor_197_impl(Identifier name) {
+  _jtd_constructor_198_impl(Identifier name) {
   }
   /**
    * Initialize a newly created synthetic field element to have the given name.
    * @param name the name of this element
    */
   FieldElementImpl.con2(String name) : super.con2(name) {
-    _jtd_constructor_198_impl(name);
+    _jtd_constructor_199_impl(name);
   }
-  _jtd_constructor_198_impl(String name) {
+  _jtd_constructor_199_impl(String name) {
   }
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.FIELD;
   bool isStatic() => hasModifier(Modifier.STATIC);
   /**
    * Set whether this field is static to correspond to the given value.
    * @param isStatic {@code true} if the field is static
    */
   void set static(bool isStatic) {
@@ skipping 40 matching lines @@
    */
   int _visibleRangeLength = -1;
   /**
    * An empty array of function elements.
    */
   static List<FunctionElement> EMPTY_ARRAY = new List<FunctionElement>(0);
   /**
    * Initialize a newly created synthetic function element.
    */
   FunctionElementImpl() : super.con2("", -1) {
-    _jtd_constructor_200_impl();
+    _jtd_constructor_201_impl();
   }
-  _jtd_constructor_200_impl() {
+  _jtd_constructor_201_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_201_impl(name);
+    _jtd_constructor_202_impl(name);
   }
-  _jtd_constructor_201_impl(Identifier name) {
+  _jtd_constructor_202_impl(Identifier name) {
   }
   /**
    * Initialize a newly created function element to have no name and the given offset. This is used
    * for function expressions, which have no name.
    * @param nameOffset the offset of the name of this element in the file that contains the
    * declaration of this element
    */
   FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset) {
-    _jtd_constructor_202_impl(nameOffset);
+    _jtd_constructor_203_impl(nameOffset);
   }
-  _jtd_constructor_202_impl(int nameOffset) {
+  _jtd_constructor_203_impl(int nameOffset) {
   }
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
   String get identifier => name;
   ElementKind get kind => ElementKind.FUNCTION;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
@@ skipping 300 matching lines @@
     this._prefix = prefix2;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     ((_importedLibrary as LibraryElementImpl)).appendTo(builder);
   }
+  String get identifier => "${_importedLibrary.name}:${(_prefix == null ? "" : _prefix.name)}";
 }
 /**
  * Instances of the class {@code LabelElementImpl} implement a {@code LabelElement}.
  * @coverage dart.engine.element
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a {@code switch} statement.
    */
   bool _onSwitchStatement = false;
@@ skipping 104 matching lines @@
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _definingCompilationUnit == ((object as LibraryElementImpl)).definingCompilationUnit;
   ElementImpl getChild(String identifier2) {
     if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier2) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
       if (((part as CompilationUnitElementImpl)).identifier == identifier2) {
         return part as CompilationUnitElementImpl;
       }
     }
+    for (ImportElement importElement in _imports) {
+      if (((importElement as ImportElementImpl)).identifier == identifier2) {
+        return importElement as ImportElementImpl;
+      }
+    }
+    for (ExportElement exportElement in _exports) {
+      if (((exportElement as ExportElementImpl)).identifier == identifier2) {
+        return exportElement as ExportElementImpl;
+      }
+    }
     return null;
   }
   AnalysisContext get context => _context;
   CompilationUnitElement get definingCompilationUnit => _definingCompilationUnit;
   FunctionElement get entryPoint => _entryPoint;
   List<LibraryElement> get exportedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ExportElement element in _exports) {
       LibraryElement library = element.exportedLibrary;
       if (library != null) {
@@ skipping 194 matching lines @@
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty array of method elements.
    */
   static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
   /**
    * Initialize a newly created method element to have the given name.
    * @param name the name of this element
    */
   MethodElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_211_impl(name);
+    _jtd_constructor_212_impl(name);
   }
-  _jtd_constructor_211_impl(Identifier name) {
+  _jtd_constructor_212_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_212_impl(name, nameOffset);
+    _jtd_constructor_213_impl(name, nameOffset);
   }
-  _jtd_constructor_212_impl(String name, int nameOffset) {
+  _jtd_constructor_213_impl(String name, int nameOffset) {
   }
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.METHOD;
   bool isAbstract() => hasModifier(Modifier.ABSTRACT);
   bool isOperator() {
     String name2 = name;
     if (name2.isEmpty) {
       return false;
     }
@@ skipping 70 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);
+  String computeDocumentationComment() => null;
   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;
@@ skipping 204 matching lines @@
   PropertyInducingElement _variable;
   /**
    * An empty array of property accessor elements.
    */
   static List<PropertyAccessorElement> EMPTY_ARRAY = new List<PropertyAccessorElement>(0);
   /**
    * Initialize a newly created property accessor element to have the given name.
    * @param name the name of this element
    */
   PropertyAccessorElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_217_impl(name);
+    _jtd_constructor_218_impl(name);
   }
-  _jtd_constructor_217_impl(Identifier name) {
+  _jtd_constructor_218_impl(Identifier name) {
   }
   /**
    * Initialize a newly created synthetic property accessor element to be associated with the given
    * variable.
    * @param variable the variable with which this access is associated
    */
   PropertyAccessorElementImpl.con2(PropertyInducingElementImpl variable2) : super.con2(variable2.name, -1) {
-    _jtd_constructor_218_impl(variable2);
+    _jtd_constructor_219_impl(variable2);
   }
-  _jtd_constructor_218_impl(PropertyInducingElementImpl variable2) {
+  _jtd_constructor_219_impl(PropertyInducingElementImpl variable2) {
     this._variable = variable2;
     synthetic = true;
   }
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
   bool operator ==(Object object) => super == object && identical(isGetter(), ((object as PropertyAccessorElement)).isGetter());
   ElementKind get kind {
     if (isGetter()) {
       return ElementKind.GETTER;
     }
     return ElementKind.SETTER;
@@ skipping 44 matching lines @@
   PropertyAccessorElement _setter;
   /**
    * An empty array of elements.
    */
   static List<PropertyInducingElement> EMPTY_ARRAY = new List<PropertyInducingElement>(0);
   /**
    * Initialize a newly created element to have the given name.
    * @param name the name of this element
    */
   PropertyInducingElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_219_impl(name);
+    _jtd_constructor_220_impl(name);
   }
-  _jtd_constructor_219_impl(Identifier name) {
+  _jtd_constructor_220_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_220_impl(name);
+    _jtd_constructor_221_impl(name);
   }
-  _jtd_constructor_220_impl(String name) {
+  _jtd_constructor_221_impl(String name) {
     synthetic = true;
   }
   PropertyAccessorElement get getter => _getter;
   PropertyAccessorElement get setter => _setter;
   /**
    * Set the getter associated with this element to the given accessor.
    * @param getter the getter associated with this element
    */
   void set getter(PropertyAccessorElement getter2) {
     this._getter = getter2;
@@ skipping 50 matching lines @@
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements TopLevelVariableElement {
   /**
    * An empty array of top-level variable elements.
    */
   static List<TopLevelVariableElement> EMPTY_ARRAY = new List<TopLevelVariableElement>(0);
   /**
    * Initialize a newly created top-level variable element to have the given name.
    * @param name the name of this element
    */
   TopLevelVariableElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_222_impl(name);
+    _jtd_constructor_223_impl(name);
   }
-  _jtd_constructor_222_impl(Identifier name) {
+  _jtd_constructor_223_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_223_impl(name);
+    _jtd_constructor_224_impl(name);
   }
-  _jtd_constructor_223_impl(String name) {
+  _jtd_constructor_224_impl(String name) {
   }
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
   bool isStatic() => true;
 }
 /**
  * Instances of the class {@code TypeVariableElementImpl} implement a {@code TypeVariableElement}.
  * @coverage dart.engine.element
  */
 class TypeVariableElementImpl extends ElementImpl implements TypeVariableElement {
@@ skipping 58 matching lines @@
   FunctionElement _initializer;
   /**
    * An empty array of variable elements.
    */
   static List<VariableElement> EMPTY_ARRAY = new List<VariableElement>(0);
   /**
    * Initialize a newly created variable element to have the given name.
    * @param name the name of this element
    */
   VariableElementImpl.con1(Identifier name) : super.con1(name) {
-    _jtd_constructor_225_impl(name);
+    _jtd_constructor_226_impl(name);
   }
-  _jtd_constructor_225_impl(Identifier name) {
+  _jtd_constructor_226_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_226_impl(name, nameOffset);
+    _jtd_constructor_227_impl(name, nameOffset);
   }
-  _jtd_constructor_226_impl(String name, int nameOffset) {
+  _jtd_constructor_227_impl(String name, int nameOffset) {
   }
   /**
    * Return the result of evaluating this variable's initializer as a compile-time constant
    * expression, or {@code null} if this variable is not a 'const' variable or does not have an
    * initializer.
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
   FunctionElement get initializer => _initializer;
   Type2 get type => _type;
@@ skipping 153 matching lines @@
   InterfaceType _definingType;
   /**
    * Initialize a newly created element to represent the member of the given parameterized type.
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   Member(Element baseElement, InterfaceType definingType) {
     this._baseElement = baseElement;
     this._definingType = definingType;
   }
+  String computeDocumentationComment() => _baseElement.computeDocumentationComment();
   Element getAncestor(Type elementClass) => baseElement.getAncestor(elementClass);
   /**
    * Return the element on which the parameterized element was created.
    * @return the element on which the parameterized element was created
    */
   Element get baseElement => _baseElement;
   AnalysisContext get context => _baseElement.context;
   ElementKind get kind => _baseElement.kind;
   LibraryElement get library => _baseElement.library;
   ElementLocation get location => _baseElement.location;
@@ skipping 411 matching lines @@
   /**
    * The type of object returned by this type of function.
    */
   Type2 _returnType = VoidTypeImpl.instance;
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    * @param element the element representing the declaration of the function type
    */
   FunctionTypeImpl.con1(ExecutableElement element) : super(element, element == null ? null : element.name) {
-    _jtd_constructor_290_impl(element);
+    _jtd_constructor_291_impl(element);
   }
-  _jtd_constructor_290_impl(ExecutableElement element) {
+  _jtd_constructor_291_impl(ExecutableElement element) {
   }
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    * @param element the element representing the declaration of the function type
    */
   FunctionTypeImpl.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name) {
-    _jtd_constructor_291_impl(element);
+    _jtd_constructor_292_impl(element);
   }
-  _jtd_constructor_291_impl(FunctionTypeAliasElement element) {
+  _jtd_constructor_292_impl(FunctionTypeAliasElement element) {
   }
   bool operator ==(Object object) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     return element == otherType.element && JavaArrays.equals(_normalParameterTypes, otherType._normalParameterTypes) && JavaArrays.equals(_optionalParameterTypes, otherType._optionalParameterTypes) && equals2(_namedParameterTypes, otherType._namedParameterTypes) && _returnType == otherType._returnType;
   }
   Map<String, Type2> get namedParameterTypes => _namedParameterTypes;
   List<Type2> get normalParameterTypes => _normalParameterTypes;
@@ skipping 268 matching lines @@
   }
   /**
    * 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_292_impl(element);
+    _jtd_constructor_293_impl(element);
   }
-  _jtd_constructor_292_impl(ClassElement element) {
+  _jtd_constructor_293_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_293_impl(name);
+    _jtd_constructor_294_impl(name);
   }
-  _jtd_constructor_293_impl(String name) {
+  _jtd_constructor_294_impl(String name) {
   }
   bool operator ==(Object object) {
     if (object is! InterfaceTypeImpl) {
       return false;
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return element == otherType.element && JavaArrays.equals(_typeArguments, otherType._typeArguments);
   }
   ClassElement get element => super.element as ClassElement;
   PropertyAccessorElement getGetter(String getterName) => PropertyAccessorMember.from(((element as ClassElementImpl)).getGetter(getterName), this);
@@ skipping 206 matching lines @@
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     InterfaceType supertype = superclass;
     while (supertype != null) {
       element = supertype.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
+      for (InterfaceType mixin in supertype.mixins) {
+        element = mixin.getGetter(getterName);
+        if (element != null && element.isAccessibleIn(library)) {
+          return element;
+        }
+      }
       supertype = supertype.superclass;
     }
     return null;
   }
   MethodElement lookUpMethod(String methodName, LibraryElement library) {
     MethodElement element = getMethod(methodName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     for (InterfaceType mixin in mixins) {
       element = mixin.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     InterfaceType supertype = superclass;
     while (supertype != null) {
       element = supertype.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
+      for (InterfaceType mixin in supertype.mixins) {
+        element = mixin.getMethod(methodName);
+        if (element != null && element.isAccessibleIn(library)) {
+          return element;
+        }
+      }
       supertype = supertype.superclass;
     }
     return null;
   }
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
     PropertyAccessorElement element = getSetter(setterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     for (InterfaceType mixin in mixins) {
       element = mixin.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     InterfaceType supertype = superclass;
     while (supertype != null) {
       element = supertype.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
+      for (InterfaceType mixin in supertype.mixins) {
+        element = mixin.getSetter(setterName);
+        if (element != null && element.isAccessibleIn(library)) {
+          return element;
+        }
+      }
       supertype = supertype.superclass;
     }
     return null;
   }
   /**
    * Set the actual types of the type arguments to those in the given array.
    * @param typeArguments the actual types of the type arguments
    */
   void set typeArguments(List<Type2> typeArguments2) {
     this._typeArguments = typeArguments2;
@@ skipping 167 matching lines @@
   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;
+ * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [[T<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>]]) &rarr;
  * T</i>.</li>
  * <li>The types of functions with named positional parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {T<sub>x1</sub> x1, &hellip;, T<sub>xk</sub> xk})
  * &rarr; T</i>.</li>
  * </ol>
  * @coverage dart.engine.type
  */
 abstract class FunctionType implements Type2 {
   /**
    * Return a map from the names of named parameters to the types of the named parameters of this
@@ skipping 39 matching lines @@
    * conditions are met:
    * <ul>
    * <li>Either
    * <ul>
    * <li><i>S</i> is void, or</li>
    * <li><i>T &hArr; S</i>.</li>
    * </ul>
    * </li>
    * <li>For all <i>i</i>, 1 <= <i>i</i> <= <i>n</i>, <i>T<sub>i</sub> &hArr; S<sub>i</sub></i>.</li>
    * </ul>
-   * A function type <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [T<sub>n+1</sub>, &hellip;,
-   * T<sub>n+k</sub>]) &rarr; T</i> is a subtype of the function type <i>(S<sub>1</sub>, &hellip;,
-   * S<sub>n</sub>, [S<sub>n+1</sub>, &hellip;, S<sub>n+m</sub>]) &rarr; S</i>, if all of the
+   * A function type <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [[T<sub>n+1</sub>, &hellip;,
+   * T<sub>n+k</sub>]]) &rarr; T</i> is a subtype of the function type <i>(S<sub>1</sub>, &hellip;,
+   * S<sub>n</sub>, [[S<sub>n+1</sub>, &hellip;, S<sub>n+m</sub>]]) &rarr; S</i>, if all of the
    * following conditions are met:
    * <ul>
    * <li>Either
    * <ul>
    * <li><i>S</i> is void, or</li>
    * <li><i>T &hArr; S</i>.</li>
    * </ul>
    * </li>
    * <li><i>k</i> >= <i>m</i> and for all <i>i</i>, 1 <= <i>i</i> <= <i>n+m</i>, <i>T<sub>i</sub>
    * &hArr; S<sub>i</sub></i>.</li>
@@ skipping 10 matching lines @@
    * </ul>
    * </li>
    * <li>For all <i>i</i>, 1 <= <i>i</i> <= <i>n</i>, <i>T<sub>i</sub> &hArr; S<sub>i</sub></i>.</li>
    * <li><i>k</i> >= <i>m</i> and <i>y<sub>i</sub></i> in <i>{x<sub>1</sub>, &hellip;,
    * x<sub>k</sub>}</i>, 1 <= <i>i</i> <= <i>m</i>.</li>
    * <li>For all <i>y<sub>i</sub></i> in <i>{y<sub>1</sub>, &hellip;, y<sub>m</sub>}</i>,
    * <i>y<sub>i</sub> = x<sub>j</sub> => Tj &hArr; Si</i>.</li>
    * </ul>
    * In addition, the following subtype rules apply:
    * <p>
-   * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, []) &rarr; T <: (T<sub>1</sub>, &hellip;,
+   * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [[]]) &rarr; T <: (T<sub>1</sub>, &hellip;,
    * T<sub>n</sub>) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T <: (T<sub>1</sub>, &hellip;,
    * T<sub>n</sub>, {}) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {}) &rarr; T <: (T<sub>1</sub>, &hellip;,
    * T<sub>n</sub>) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T <: (T<sub>1</sub>, &hellip;,
-   * T<sub>n</sub>, []) &rarr; T.</i>
+   * T<sub>n</sub>, [[]]) &rarr; T.</i>
    * <p>
    * All functions implement the class {@code Function}. However not all function types are a
    * subtype of {@code Function}. If an interface type <i>I</i> includes a method named{@code call()}, and the type of {@code call()} is the function type <i>F</i>, then <i>I</i> is
    * considered to be a subtype of <i>F</i>.
    * @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 the type resulting from substituting the given arguments for this type's parameters.
@@ skipping 110 matching lines @@
    * <i>T<sub>i</sub> &laquo; S<sub>i</sub></i>, <i>1 <= i <= n</i>.
    * <li>Transitivity: <i>T &laquo; U</i> and <i>U &laquo; S</i>.
    * </ul>
    * @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. An interface type <i>T</i> is
    * a subtype of an interface type <i>S</i>, written <i>T</i> <: <i>S</i>, iff
-   * <i>[bottom/dynamic]T</i> &laquo; <i>S</i> (<i>T</i> is more specific than <i>S</i>). If an
+   * <i>[[bottom/dynamic]]T</i> &laquo; <i>S</i> (<i>T</i> is more specific than <i>S</i>). If an
    * interface type <i>I</i> includes a method named <i>call()</i>, and the type of <i>call()</i> is
    * the function type <i>F</i>, then <i>I</i> is considered to be a subtype of <i>F</i>.
    * @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 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:
@@ skipping 127 matching lines @@
    */
   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>[[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.
  * @coverage dart.engine.type
  */
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }