New analyzer snapshot with MapIterator.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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';
@@ skipping 394 matching lines @@
    * @return the class with the given name that is defined in this compilation unit
    */
   ClassElement getType(String className);
 
   /**
    * 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 `true` if this compilation unit defines a top-level function named
+   * `loadLibrary`.
+   *
+   * @return `true` if this compilation unit defines a top-level function named
+   *         `loadLibrary`
+   */
+  bool get hasLoadLibraryFunction;
 }
 
 /**
  * The interface `ConstructorElement` defines the behavior of elements representing a
  * constructor or a factory method defined within a type.
  */
 abstract class ConstructorElement implements ClassMemberElement, ExecutableElement {
   /**
    * Return the resolved [ConstructorDeclaration] node that declares this
    * [ConstructorElement] .
@@ skipping 353 matching lines @@
   static const ElementKind LIBRARY = const ElementKind('LIBRARY', 22, "library");
 
   static const ElementKind LOCAL_VARIABLE = const ElementKind('LOCAL_VARIABLE', 23, "local variable");
 
   static const ElementKind METHOD = const ElementKind('METHOD', 24, "method");
 
   static const ElementKind NAME = const ElementKind('NAME', 25, "<name>");
 
   static const ElementKind PARAMETER = const ElementKind('PARAMETER', 26, "parameter");
 
-  static const ElementKind PREFIX = const ElementKind('PREFIX', 27, "import prefix");
+  static const ElementKind POLYMER_ATTRIBUTE = const ElementKind('POLYMER_ATTRIBUTE', 27, "Polymer attribute");
 
-  static const ElementKind SETTER = const ElementKind('SETTER', 28, "setter");
+  static const ElementKind POLYMER_TAG_DART = const ElementKind('POLYMER_TAG_DART', 28, "Polymer Dart tag");
 
-  static const ElementKind TOP_LEVEL_VARIABLE = const ElementKind('TOP_LEVEL_VARIABLE', 29, "top level variable");
+  static const ElementKind POLYMER_TAG_HTML = const ElementKind('POLYMER_TAG_HTML', 29, "Polymer HTML tag");
 
-  static const ElementKind FUNCTION_TYPE_ALIAS = const ElementKind('FUNCTION_TYPE_ALIAS', 30, "function type alias");
+  static const ElementKind PREFIX = const ElementKind('PREFIX', 30, "import prefix");
 
-  static const ElementKind TYPE_PARAMETER = const ElementKind('TYPE_PARAMETER', 31, "type parameter");
+  static const ElementKind SETTER = const ElementKind('SETTER', 31, "setter");
 
-  static const ElementKind UNIVERSE = const ElementKind('UNIVERSE', 32, "<universe>");
+  static const ElementKind TOP_LEVEL_VARIABLE = const ElementKind('TOP_LEVEL_VARIABLE', 32, "top level variable");
+
+  static const ElementKind FUNCTION_TYPE_ALIAS = const ElementKind('FUNCTION_TYPE_ALIAS', 33, "function type alias");
+
+  static const ElementKind TYPE_PARAMETER = const ElementKind('TYPE_PARAMETER', 34, "type parameter");
+
+  static const ElementKind UNIVERSE = const ElementKind('UNIVERSE', 35, "<universe>");
 
   static const List<ElementKind> values = const [
       ANGULAR_FILTER,
       ANGULAR_COMPONENT,
       ANGULAR_CONTROLLER,
       ANGULAR_DIRECTIVE,
       ANGULAR_PROPERTY,
       ANGULAR_SCOPE_PROPERTY,
       ANGULAR_SELECTOR,
       ANGULAR_VIEW,
       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,
+      POLYMER_ATTRIBUTE,
+      POLYMER_TAG_DART,
+      POLYMER_TAG_HTML,
       PREFIX,
       SETTER,
       TOP_LEVEL_VARIABLE,
       FUNCTION_TYPE_ALIAS,
       TYPE_PARAMETER,
       UNIVERSE];
 
   /**
    * Return the kind of the given element, or [ERROR] if the element is `null`. This is
    * a utility method that can reduce the need for null checks in other places.
@@ skipping 85 matching lines @@
   R visitLibraryElement(LibraryElement element);
 
   R visitLocalVariableElement(LocalVariableElement element);
 
   R visitMethodElement(MethodElement element);
 
   R visitMultiplyDefinedElement(MultiplyDefinedElement element);
 
   R visitParameterElement(ParameterElement element);
 
+  R visitPolymerAttributeElement(PolymerAttributeElement element);
+
+  R visitPolymerTagDartElement(PolymerTagDartElement element);
+
+  R visitPolymerTagHtmlElement(PolymerTagHtmlElement element);
+
   R visitPrefixElement(PrefixElement element);
 
   R visitPropertyAccessorElement(PropertyAccessorElement element);
 
   R visitTopLevelVariableElement(TopLevelVariableElement element);
 
   R visitTypeParameterElement(TypeParameterElement element);
 }
 
 /**
@@ skipping 134 matching lines @@
    * @return the field element associated with this field formal parameter
    */
   FieldElement get field;
 }
 
 /**
  * The interface `FunctionElement` defines the behavior of elements representing a function.
  */
 abstract class FunctionElement implements ExecutableElement, LocalElement {
   /**
+   * The name of the synthetic function defined for libraries that are deferred.
+   */
+  static final String LOAD_LIBRARY_NAME = "loadLibrary";
+
+  /**
    * Return the resolved [FunctionDeclaration] node that declares this [FunctionElement]
    * .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [FunctionDeclaration], not `null`.
    */
   @override
   FunctionDeclaration get node;
@@ skipping 71 matching lines @@
  * The interface `HtmlElement` defines the behavior of elements representing an HTML file.
  */
 abstract class HtmlElement implements Element {
   /**
    * Return the [CompilationUnitElement] associated with this Angular HTML file, maybe
    * `null` if not an Angular file.
    */
   CompilationUnitElement get angularCompilationUnit;
 
   /**
+   * Return an array containing all of the [PolymerTagHtmlElement]s defined in the HTML file.
+   *
+   * @return the [PolymerTagHtmlElement]s elements in the HTML file (not `null`,
+   *         contains no `null`s)
+   */
+  List<PolymerTagHtmlElement> get polymerTags;
+
+  /**
    * Return an array containing all of the script elements contained in the HTML file. This includes
    * scripts with libraries that are defined by the content of a script tag as well as libraries
    * that are referenced in the {@core source} attribute of a script tag.
    *
    * @return the script elements in the HTML file (not `null`, contains no `null`s)
    */
   List<HtmlScriptElement> get scripts;
 }
 
 /**
@@ skipping 40 matching lines @@
   PrefixElement get prefix;
 
   /**
    * Return the offset of the prefix of this import in the file that contains this import directive,
    * or `-1` if this import is synthetic, does not have a prefix, or otherwise does not have
    * an offset.
    *
    * @return the offset of the prefix of this import
    */
   int get prefixOffset;
+
+  /**
+   * Return `true` if this import is for a deferred library.
+   *
+   * @return `true` if this import is for a deferred library
+   */
+  bool get isDeferred;
 }
 
 /**
  * The interface `LabelElement` defines the behavior of elements representing a label
  * associated with a statement.
  */
 abstract class LabelElement implements Element {
   /**
    * Return the executable element in which this label is defined.
    *
@@ skipping 94 matching lines @@
    */
   List<LibraryElement> get visibleLibraries;
 
   /**
    * Return `true` if the defining compilation unit of this library contains at least one
    * import directive whose URI uses the "dart-ext" scheme.
    */
   bool get hasExtUri;
 
   /**
+   * Return `true` if this library defines a top-level function named `loadLibrary`.
+   *
+   * @return `true` if this library defines a top-level function named `loadLibrary`
+   */
+  bool get hasLoadLibraryFunction;
+
+  /**
    * Return `true` if this library is created for Angular analysis. If this library has not
    * yet had toolkit references resolved, then `false` will be returned.
    *
    * @return `true` if this library is created for Angular analysis
    */
   bool get isAngularHtml;
 
   /**
    * Answer `true` if this library is an application that can be run in the browser.
    *
@@ skipping 507 matching lines @@
    */
   bool isClass(String name);
 }
 
 /**
  * The interface `AngularElement` defines the behavior of objects representing information
  * about an Angular specific element.
  */
 abstract class AngularElement implements ToolkitObjectElement {
   /**
-   * An empty array of angular elements.
+   * An empty array of Angular elements.
    */
   static final List<AngularElement> EMPTY_ARRAY = new List<AngularElement>(0);
 
   /**
    * Returns the [AngularApplication] this element is used in.
    *
    * @return the [AngularApplication] this element is used in
    */
   AngularApplication get application;
 }
@@ skipping 190 matching lines @@
  * <code>view('views/create.html')</code>.
  */
 abstract class AngularViewElement implements AngularHasTemplateElement {
   /**
    * An empty array of view elements.
    */
   static final List<AngularViewElement> EMPTY_ARRAY = new List<AngularViewElement>(0);
 }
 
 /**
+ * The interface `PolymerAttributeElement` defines an attribute in
+ * [PolymerTagHtmlElement].
+ *
+ * <pre>
+ * <polymer-element name="my-example" attributes='attrA attrB'>
+ * </polymer-element>
+ * </pre>
+ */
+abstract class PolymerAttributeElement implements PolymerElement {
+  /**
+   * An empty array of Polymer custom tag attributes.
+   */
+  static final List<PolymerAttributeElement> EMPTY_ARRAY = new List<PolymerAttributeElement>(0);
+
+  /**
+   * Return the [FieldElement] associated with this attribute. Maybe `null` if
+   * [PolymerTagDartElement] does not have a field associated with it.
+   */
+  FieldElement get field;
+}
+
+/**
+ * The interface `PolymerElement` defines the behavior of objects representing information
+ * about a Polymer specific element.
+ */
+abstract class PolymerElement implements ToolkitObjectElement {
+  /**
+   * An empty array of Polymer elements.
+   */
+  static final List<PolymerElement> EMPTY_ARRAY = new List<PolymerElement>(0);
+}
+
+/**
+ * The interface `PolymerTagDartElement` defines a Polymer custom tag in Dart.
+ *
+ * <pre>
+ * @CustomTag('my-example')
+ * </pre>
+ */
+abstract class PolymerTagDartElement implements PolymerElement {
+  /**
+   * Return the [ClassElement] that is associated with this Polymer custom tag. Not
+   * `null`, because [PolymerTagDartElement]s are created for [ClassElement]s
+   * marked with the `@CustomTag` annotation.
+   */
+  ClassElement get classElement;
+
+  /**
+   * Return the [PolymerTagHtmlElement] part of this Polymer custom tag. Maybe `null` if
+   * it has not been resolved yet or there are no corresponding Dart part defined.
+   */
+  PolymerTagHtmlElement get htmlElement;
+}
+
+/**
+ * The interface `PolymerTagHtmlElement` defines a Polymer custom tag in HTML.
+ *
+ * <pre>
+ * <polymer-element name="my-example" attributes='attrA attrB'>
+ * </polymer-element>
+ * </pre>
+ */
+abstract class PolymerTagHtmlElement implements PolymerElement {
+  /**
+   * An empty array of [PolymerTagHtmlElement]s.
+   */
+  static final List<PolymerTagHtmlElement> EMPTY_ARRAY = new List<PolymerTagHtmlElement>(0);
+
+  /**
+   * Return an array containing all of the attributes declared by this tag.
+   */
+  List<PolymerAttributeElement> get attributes;
+
+  /**
+   * Return the [PolymerTagDartElement] part on this Polymer custom tag. Maybe `null` if
+   * it has not been resolved yet or there are no corresponding Dart part defined.
+   */
+  PolymerTagDartElement get dartElement;
+}
+
+/**
  * Instances of the class `GeneralizingElementVisitor` implement an element visitor that will
  * recursively visit all of the elements in an element model (like instances of the class
  * [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 [MethodElement] will cause the method
  * [visitMethodElement] to be invoked but will also cause the methods
  * [visitExecutableElement] and [visitElement] 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
@@ skipping 138 matching lines @@
   @override
   R visitMethodElement(MethodElement element) => visitExecutableElement(element);
 
   @override
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) => visitElement(element);
 
   @override
   R visitParameterElement(ParameterElement element) => visitLocalElement(element);
 
   @override
+  R visitPolymerAttributeElement(PolymerAttributeElement element) => visitPolymerElement(element);
+
+  R visitPolymerElement(PolymerElement element) => visitToolkitObjectElement(element);
+
+  @override
+  R visitPolymerTagDartElement(PolymerTagDartElement element) => visitPolymerElement(element);
+
+  @override
+  R visitPolymerTagHtmlElement(PolymerTagHtmlElement element) => visitPolymerElement(element);
+
+  @override
   R visitPrefixElement(PrefixElement element) => visitElement(element);
 
   @override
   R visitPropertyAccessorElement(PropertyAccessorElement element) => visitExecutableElement(element);
 
   R visitPropertyInducingElement(PropertyInducingElement element) => visitVariableElement(element);
 
   R visitToolkitObjectElement(ToolkitObjectElement element) => visitElement(element);
 
   @override
@@ skipping 166 matching lines @@
     return null;
   }
 
   @override
   R visitParameterElement(ParameterElement element) {
     element.visitChildren(this);
     return null;
   }
 
   @override
+  R visitPolymerAttributeElement(PolymerAttributeElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+
+  @override
+  R visitPolymerTagDartElement(PolymerTagDartElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+
+  @override
+  R visitPolymerTagHtmlElement(PolymerTagHtmlElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+
+  @override
   R visitPrefixElement(PrefixElement element) {
     element.visitChildren(this);
     return null;
   }
 
   @override
   R visitPropertyAccessorElement(PropertyAccessorElement element) {
     element.visitChildren(this);
     return null;
   }
@@ skipping 90 matching lines @@
   @override
   R visitMethodElement(MethodElement element) => null;
 
   @override
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) => null;
 
   @override
   R visitParameterElement(ParameterElement element) => null;
 
   @override
+  R visitPolymerAttributeElement(PolymerAttributeElement element) => null;
+
+  @override
+  R visitPolymerTagDartElement(PolymerTagDartElement element) => null;
+
+  @override
+  R visitPolymerTagHtmlElement(PolymerTagHtmlElement element) => null;
+
+  @override
   R visitPrefixElement(PrefixElement element) => null;
 
   @override
   R visitPropertyAccessorElement(PropertyAccessorElement element) => null;
 
   @override
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
 
   @override
   R visitTypeParameterElement(TypeParameterElement element) => null;
@@ skipping 91 matching lines @@
   /**
    * Initialize a newly created class element to have the given name.
    *
    * @param name the name of this element
    */
   ClassElementImpl(Identifier name) : super.forNode(name);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitClassElement(this);
 
+  /**
+   * Set the toolkit specific information objects attached to this class.
+   *
+   * @param toolkitObjects the toolkit objects attached to this class
+   */
+  void addToolkitObjects(ToolkitObjectElement toolkitObject) {
+    (toolkitObject as ToolkitObjectElementImpl).enclosingElement = this;
+    _toolkitObjects = ArrayUtils.add(_toolkitObjects, toolkitObject);
+  }
+
   @override
   List<PropertyAccessorElement> get accessors => _accessors;
 
   @override
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     _collectAllSupertypes(list);
     return new List.from(list);
   }
 
@@ skipping 336 matching lines @@
    * @param methods the methods contained in this class
    */
   void set methods(List<MethodElement> methods) {
     for (MethodElement method in methods) {
       (method as MethodElementImpl).enclosingElement = this;
     }
     this._methods = methods;
   }
 
   /**
-   * Set the toolkit specific information objects attached to this class.
-   *
-   * @param toolkitObjects the toolkit objects attached to this class
-   */
-  void set toolkitObjects(List<ToolkitObjectElement> toolkitObjects) {
-    for (ToolkitObjectElement toolkitObject in toolkitObjects) {
-      (toolkitObject as ToolkitObjectElementImpl).enclosingElement = this;
-    }
-    this._toolkitObjects = toolkitObjects;
-  }
-
-  /**
    * Set whether this class is defined by a typedef construct to correspond to the given value.
    *
    * @param isTypedef `true` if the class is defined by a typedef construct
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
 
   /**
    * Set the type parameters defined for this class to the given type parameters.
@@ skipping 234 matching lines @@
     }
     return null;
   }
 
   @override
   List<ClassElement> get types => _types;
 
   @override
   int get hashCode => source.hashCode;
 
+  @override
+  bool get hasLoadLibraryFunction {
+    for (int i = 0; i < _functions.length; i++) {
+      if (_functions[i].name == FunctionElement.LOAD_LIBRARY_NAME) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * 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> accessors) {
     for (PropertyAccessorElement accessor in accessors) {
       (accessor as PropertyAccessorElementImpl).enclosingElement = this;
     }
@@ skipping 1664 matching lines @@
    * The analysis context in which this library is defined.
    */
   final AnalysisContext context;
 
   /**
    * The scripts contained in or referenced from script tags in the HTML file.
    */
   List<HtmlScriptElement> _scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
 
   /**
+   * The [PolymerTagHtmlElement]s defined in the HTML file.
+   */
+  List<PolymerTagHtmlElement> _polymerTags = PolymerTagHtmlElement.EMPTY_ARRAY;
+
+  /**
    * The source that corresponds to this HTML file.
    */
   Source source;
 
   /**
    * The element associated with Dart pieces in this HTML unit or `null` if the receiver is
    * not resolved.
    */
   CompilationUnitElement angularCompilationUnit;
 
@@ skipping 16 matching lines @@
     if (object == null) {
       return false;
     }
     return runtimeType == object.runtimeType && source == (object as HtmlElementImpl).source;
   }
 
   @override
   ElementKind get kind => ElementKind.HTML;
 
   @override
+  List<PolymerTagHtmlElement> get polymerTags => _polymerTags;
+
+  @override
   List<HtmlScriptElement> get scripts => _scripts;
 
   @override
   int get hashCode => source.hashCode;
 
   /**
+   * Set the [PolymerTagHtmlElement]s defined in the HTML file.
+   */
+  void set polymerTags(List<PolymerTagHtmlElement> polymerTags) {
+    if (polymerTags.length == 0) {
+      this._polymerTags = PolymerTagHtmlElement.EMPTY_ARRAY;
+      return;
+    }
+    for (PolymerTagHtmlElement tag in polymerTags) {
+      (tag as PolymerTagHtmlElementImpl).enclosingElement = this;
+    }
+    this._polymerTags = polymerTags;
+  }
+
+  /**
    * Set the scripts contained in the HTML file to the given scripts.
    *
    * @param scripts the scripts
    */
   void set scripts(List<HtmlScriptElement> scripts) {
     if (scripts.length == 0) {
-      scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
+      this._scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
+      return;
     }
     for (HtmlScriptElement script in scripts) {
       (script as HtmlScriptElementImpl).enclosingElement = this;
     }
     this._scripts = scripts;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
+    safelyVisitChildren(_polymerTags, visitor);
   }
 
   @override
   void appendTo(JavaStringBuilder builder) {
     if (source == null) {
       builder.append("{HTML file}");
     } else {
       builder.append(source.fullName);
     }
   }
@@ skipping 50 matching lines @@
    */
   ImportElementImpl(int offset) : super(null, offset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
 
   @override
   ElementKind get kind => ElementKind.IMPORT;
 
   @override
+  bool get isDeferred => hasModifier(Modifier.DEFERRED);
+
+  /**
+   * Set whether this import is for a deferred library to correspond to the given value.
+   *
+   * @param isDeferred `true` if this import is for a deferred library
+   */
+  void set deferred(bool isDeferred) {
+    setModifier(Modifier.DEFERRED, isDeferred);
+  }
+
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(prefix, visitor);
   }
 
   @override
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     (importedLibrary as LibraryElementImpl).appendTo(builder);
   }
@@ skipping 268 matching lines @@
     return new List.from(visibleLibraries);
   }
 
   @override
   bool get hasExtUri => hasModifier(Modifier.HAS_EXT_URI);
 
   @override
   int get hashCode => _definingCompilationUnit.hashCode;
 
   @override
+  bool get hasLoadLibraryFunction {
+    if (_definingCompilationUnit.hasLoadLibraryFunction) {
+      return true;
+    }
+    for (int i = 0; i < _parts.length; i++) {
+      if (_parts[i].hasLoadLibraryFunction) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @override
   bool get isAngularHtml => _isAngularHtml;
 
   @override
   bool get isBrowserApplication => entryPoint != null && isOrImportsBrowserLibrary;
 
   @override
   bool get isDartCore => name == "dart.core";
 
   @override
   bool get isInSdk => StringUtilities.startsWith5(name, 0, 0x64, 0x61, 0x72, 0x74, 0x2E);
@@ skipping 356 matching lines @@
    * Indicates that the modifier 'abstract' was applied to the element.
    */
   static const Modifier ABSTRACT = const Modifier('ABSTRACT', 0);
 
   /**
    * Indicates that the modifier 'const' was applied to the element.
    */
   static const Modifier CONST = const Modifier('CONST', 1);
 
   /**
+   * Indicates that the import element represents a deferred library.
+   */
+  static const Modifier DEFERRED = const Modifier('DEFERRED', 2);
+
+  /**
    * Indicates that the modifier 'factory' was applied to the element.
    */
-  static const Modifier FACTORY = const Modifier('FACTORY', 2);
+  static const Modifier FACTORY = const Modifier('FACTORY', 3);
 
   /**
    * Indicates that the modifier 'final' was applied to the element.
    */
-  static const Modifier FINAL = const Modifier('FINAL', 3);
+  static const Modifier FINAL = const Modifier('FINAL', 4);
 
   /**
    * Indicates that the pseudo-modifier 'get' was applied to the element.
    */
-  static const Modifier GETTER = const Modifier('GETTER', 4);
+  static const Modifier GETTER = const Modifier('GETTER', 5);
 
   /**
    * A flag used for libraries indicating that the defining compilation unit contains at least one
    * import directive whose URI uses the "dart-ext" scheme.
    */
-  static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 5);
+  static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 6);
 
-  static const Modifier MIXIN = const Modifier('MIXIN', 6);
+  static const Modifier MIXIN = const Modifier('MIXIN', 7);
 
-  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 7);
+  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 8);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static const Modifier SETTER = const Modifier('SETTER', 8);
+  static const Modifier SETTER = const Modifier('SETTER', 9);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static const Modifier STATIC = const Modifier('STATIC', 9);
+  static const Modifier STATIC = const Modifier('STATIC', 10);
 
   /**
    * Indicates that the element does not appear in the source code but was implicitly created. For
    * example, if a class does not define any constructors, an implicit zero-argument constructor
    * will be created and it will be marked as being synthetic.
    */
-  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 10);
+  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 11);
 
-  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 11);
+  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 12);
 
   static const List<Modifier> values = const [
       ABSTRACT,
       CONST,
+      DEFERRED,
       FACTORY,
       FINAL,
       GETTER,
       HAS_EXT_URI,
       MIXIN,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
@@ skipping 2194 matching lines @@
   @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used below so that we can
     // safely invoke them.
     super.visitChildren(visitor);
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }
 
 /**
+ * Implementation of `PolymerAttributeElement`.
+ */
+class PolymerAttributeElementImpl extends PolymerElementImpl implements PolymerAttributeElement {
+  /**
+   * The [FieldElement] associated with this attribute.
+   */
+  FieldElement field;
+
+  /**
+   * Initialize a newly created Polymer attribute 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
+   */
+  PolymerAttributeElementImpl(String name, int nameOffset) : super(name, nameOffset);
+
+  @override
+  accept(ElementVisitor visitor) => visitor.visitPolymerAttributeElement(this);
+
+  @override
+  ElementKind get kind => ElementKind.POLYMER_ATTRIBUTE;
+}
+
+/**
+ * Implementation of `PolymerElement`.
+ */
+abstract class PolymerElementImpl extends ToolkitObjectElementImpl implements PolymerElement {
+  /**
+   * Initialize a newly created Polymer 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
+   */
+  PolymerElementImpl(String name, int nameOffset) : super(name, nameOffset);
+}
+
+/**
+ * Implementation of `PolymerTagDartElement`.
+ */
+class PolymerTagDartElementImpl extends PolymerElementImpl implements PolymerTagDartElement {
+  /**
+   * The [ClassElement] that is associated with this Polymer custom tag.
+   */
+  final ClassElement classElement;
+
+  /**
+   * The [PolymerTagHtmlElement] part of this Polymer custom tag. Maybe `null` if it has
+   * not been resolved yet or there are no corresponding Dart part defined.
+   */
+  PolymerTagHtmlElement htmlElement;
+
+  /**
+   * Initialize a newly created Dart part of a Polymer tag 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
+   */
+  PolymerTagDartElementImpl(String name, int nameOffset, this.classElement) : super(name, nameOffset);
+
+  @override
+  accept(ElementVisitor visitor) => visitor.visitPolymerTagDartElement(this);
+
+  @override
+  ElementKind get kind => ElementKind.POLYMER_TAG_DART;
+}
+
+/**
+ * Implementation of `PolymerTagHtmlElement`.
+ */
+class PolymerTagHtmlElementImpl extends PolymerElementImpl implements PolymerTagHtmlElement {
+  /**
+   * The [PolymerTagDartElement] part of this Polymer custom tag. Maybe `null` if it has
+   * not been resolved yet or there are no corresponding Dart part defined.
+   */
+  PolymerTagDartElement dartElement;
+
+  /**
+   * The array containing all of the attributes declared by this tag.
+   */
+  List<PolymerAttributeElement> _attributes = PolymerAttributeElement.EMPTY_ARRAY;
+
+  /**
+   * Initialize a newly created HTML part of a Polymer tag 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
+   */
+  PolymerTagHtmlElementImpl(String name, int nameOffset) : super(name, nameOffset);
+
+  @override
+  accept(ElementVisitor visitor) => visitor.visitPolymerTagHtmlElement(this);
+
+  @override
+  List<PolymerAttributeElement> get attributes => _attributes;
+
+  @override
+  ElementKind get kind => ElementKind.POLYMER_TAG_HTML;
+
+  /**
+   * Set an array containing all of the attributes declared by this tag.
+   *
+   * @param attributes the properties to set
+   */
+  void set attributes(List<PolymerAttributeElement> attributes) {
+    for (PolymerAttributeElement property in attributes) {
+      encloseElement(property as PolymerAttributeElementImpl);
+    }
+    this._attributes = attributes;
+  }
+
+  @override
+  void visitChildren(ElementVisitor visitor) {
+    safelyVisitChildren(_attributes, visitor);
+    super.visitChildren(visitor);
+  }
+}
+
+/**
  * The unique instance of the class `BottomTypeImpl` implements the type `bottom`.
  */
 class BottomTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static BottomTypeImpl _INSTANCE = new BottomTypeImpl();
 
   /**
    * Return the unique instance of this class.
@@ skipping 108 matching lines @@
    * @param firstTypes the first map of name/type pairs being compared
    * @param secondTypes the second map of name/type pairs being compared
    * @param visitedElementPairs a set of visited element pairs
    * @return `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 _equals(Map<String, DartType> firstTypes, Map<String, DartType> secondTypes, Set<ElementPair> visitedElementPairs) {
     if (secondTypes.length != firstTypes.length) {
       return false;
     }
-    JavaIterator<MapEntry<String, DartType>> firstIterator = new JavaIterator(getMapEntrySet(firstTypes));
-    JavaIterator<MapEntry<String, DartType>> secondIterator = new JavaIterator(getMapEntrySet(secondTypes));
-    while (firstIterator.hasNext) {
-      MapEntry<String, DartType> firstEntry = firstIterator.next();
-      MapEntry<String, DartType> secondEntry = secondIterator.next();
-      if (firstEntry.getKey() != secondEntry.getKey() || !(firstEntry.getValue() as TypeImpl).internalEquals(secondEntry.getValue(), visitedElementPairs)) {
+    MapIterator<String, DartType> firstIterator = SingleMapIterator.forMap(firstTypes);
+    MapIterator<String, DartType> secondIterator = SingleMapIterator.forMap(secondTypes);
+    while (firstIterator.moveNext() && secondIterator.moveNext()) {
+      if (firstIterator.key != secondIterator.key || !(firstIterator.value as TypeImpl).internalEquals(secondIterator.value, visitedElementPairs)) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * An array containing the actual types of the type arguments.
    */
   List<DartType> typeArguments = TypeImpl.EMPTY_ARRAY;
@@ skipping 55 matching lines @@
         }
         builder.append("]");
         needsComma = true;
       }
       if (namedParameterTypes.length > 0) {
         if (needsComma) {
           builder.append(", ");
           needsComma = false;
         }
         builder.append("{");
-        for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
+        for (MapIterator<String, DartType> iter = SingleMapIterator.forMap(namedParameterTypes); iter.moveNext();) {
           if (needsComma) {
             builder.append(", ");
           } else {
             needsComma = true;
           }
-          builder.append(entry.getKey());
+          builder.append(iter.key);
           builder.append(": ");
-          builder.append(entry.getValue().displayName);
+          builder.append(iter.value.displayName);
         }
         builder.append("}");
         needsComma = true;
       }
       builder.append(")");
       builder.append(Element.RIGHT_ARROW);
       if (returnType == null) {
         builder.append("null");
       } else {
         builder.append(returnType.displayName);
@@ skipping 150 matching lines @@
         }
       }
       Map<String, DartType> namedTypesT = t.namedParameterTypes;
       Map<String, DartType> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching parameter name and that the
       // corresponding type is more specific then the type in S.
-      JavaIterator<MapEntry<String, DartType>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
-      while (iteratorS.hasNext) {
-        MapEntry<String, DartType> entryS = iteratorS.next();
-        DartType typeT = namedTypesT[entryS.getKey()];
+      MapIterator<String, DartType> iteratorS = SingleMapIterator.forMap(namedTypesS);
+      while (iteratorS.moveNext()) {
+        DartType typeT = namedTypesT[iteratorS.key];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isMoreSpecificThan2(entryS.getValue(), withDynamic, visitedTypePairs)) {
+        if (!(typeT as TypeImpl).isMoreSpecificThan2(iteratorS.value, withDynamic, visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal to the number of
@@ skipping 92 matching lines @@
       }
       builder.append("]");
       needsComma = true;
     }
     if (namedParameterTypes.length > 0) {
       if (needsComma) {
         builder.append(", ");
         needsComma = false;
       }
       builder.append("{");
-      for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
+      for (MapIterator<String, DartType> iter = SingleMapIterator.forMap(namedParameterTypes); iter.moveNext();) {
         if (needsComma) {
           builder.append(", ");
         } else {
           needsComma = true;
         }
-        builder.append(entry.getKey());
+        builder.append(iter.key);
         builder.append(": ");
-        (entry.getValue() as TypeImpl).appendTo(builder);
+        (iter.value as TypeImpl).appendTo(builder);
       }
       builder.append("}");
       needsComma = true;
     }
     builder.append(")");
     builder.append(Element.RIGHT_ARROW);
     if (returnType == null) {
       builder.append("null");
     } else {
       (returnType as TypeImpl).appendTo(builder);
@@ skipping 67 matching lines @@
         }
       }
       Map<String, DartType> namedTypesT = t.namedParameterTypes;
       Map<String, DartType> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching parameter name and that the
       // corresponding type is assignable to the type in S.
-      JavaIterator<MapEntry<String, DartType>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
-      while (iteratorS.hasNext) {
-        MapEntry<String, DartType> entryS = iteratorS.next();
-        DartType typeT = namedTypesT[entryS.getKey()];
+      MapIterator<String, DartType> iteratorS = SingleMapIterator.forMap(namedTypesS);
+      while (iteratorS.moveNext()) {
+        DartType typeT = namedTypesT[iteratorS.key];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isAssignableTo2(entryS.getValue(), visitedTypePairs)) {
+        if (!(typeT as TypeImpl).isAssignableTo2(iteratorS.value, visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal to the number of
@@ skipping 1778 matching lines @@
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
   @override
   VoidType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }