New analyzer snapshot with MapIterator.

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'java_core.dart';
@@ skipping 809 matching lines @@
   bool get analyzeAngular;
 
   /**
    * Return `true` if analysis is to parse and analyze function bodies.
    *
    * @return `true` if analysis is to parse and analyzer function bodies
    */
   bool get analyzeFunctionBodies;
 
   /**
+   * Return `true` if analysis is to analyze Polymer.
+   *
+   * @return `true` if analysis is to analyze Polymer
+   */
+  bool get analyzePolymer;
+
+  /**
    * Return the maximum number of sources for which AST structures should be kept in the cache.
    *
    * @return the maximum number of sources for which AST structures should be kept in the cache
    */
   int get cacheSize;
 
   /**
    * Return `true` if analysis is to generate dart2js related hint results.
    *
    * @return `true` if analysis is to generate dart2js related hint results
@@ skipping 339 matching lines @@
     }
     while (_recentlyUsed.length >= _maxCacheSize) {
       if (!_flushAstFromCache()) {
         break;
       }
     }
     _recentlyUsed.add(source);
   }
 
   /**
-   * Return a collection containing all of the map entries mapping sources to cache entries. Clients
-   * should not modify the returned collection.
-   *
-   * @return a collection containing all of the map entries mapping sources to cache entries
-   */
-  Iterable<MapEntry<Source, SourceEntry>> entrySet() => getMapEntrySet(_sourceMap);
-
-  /**
    * Return the entry associated with the given source.
    *
    * @param source the source whose entry is to be returned
    * @return the entry associated with the given source
    */
   SourceEntry get(Source source) => _sourceMap[source];
 
   /**
+   * Return an iterator returning all of the map entries mapping sources to cache entries.
+   *
+   * @return an iterator returning all of the map entries mapping sources to cache entries
+   */
+  MapIterator<Source, SourceEntry> iterator() => new SingleMapIterator<Source, SourceEntry>(_sourceMap);
+
+  /**
    * Associate the given entry with the given source.
    *
    * @param source the source with which the entry is to be associated
    * @param entry the entry to be associated with the source
    */
   void put(Source source, SourceEntry entry) {
     (entry as SourceEntryImpl).fixExceptionState();
     _sourceMap[source] = entry;
   }
 
@@ skipping 180 matching lines @@
  * The interface `DartEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual Dart file.
  */
 abstract class DartEntry implements SourceEntry {
   /**
    * The data descriptor representing the errors reported during Angular resolution.
    */
   static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.ANGULAR_ERRORS");
 
   /**
+   * The data descriptor representing the errors reported while building an element model.
+   */
+  static final DataDescriptor<List<AnalysisError>> BUILD_ELEMENT_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.BUILD_ELEMENT_ERRORS");
+
+  /**
    * The data descriptor representing the list of libraries that contain this compilation unit.
    */
   static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.CONTAINING_LIBRARIES");
 
   /**
    * The data descriptor representing the library element for the library. This data is only
    * available for Dart files that are the defining compilation unit of a library.
    */
   static final DataDescriptor<LibraryElement> ELEMENT = new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
 
@@ skipping 335 matching lines @@
     _resolutionState.flushAstStructures();
   }
 
   @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     ListUtilities.addAll(errors, _scanErrors);
     ListUtilities.addAll(errors, _parseErrors);
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
+      ListUtilities.addAll(errors, state._buildElementErrors);
       ListUtilities.addAll(errors, state._resolutionErrors);
       ListUtilities.addAll(errors, state._verificationErrors);
       ListUtilities.addAll(errors, state._hints);
       state = state._nextState;
     }
     ListUtilities.addAll(errors, _angularErrors);
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
@@ skipping 103 matching lines @@
     } else {
       return super.getState(descriptor);
     }
   }
 
   @override
   CacheState getStateInLibrary(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
-        if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
+        if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS)) {
+          return state._buildElementErrorsState;
+        } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrorsState;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnitState;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrorsState;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hintsState;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
+    if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS) || identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return CacheState.INVALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       return _angularErrors;
@@ skipping 26 matching lines @@
       return _tokenStream;
     }
     return super.getValue(descriptor);
   }
 
   @override
   Object getValueInLibrary(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
-        if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
+        if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS)) {
+          return state._buildElementErrors;
+        } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrors;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnit;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrors;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hints;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
+    if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS) || identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return AnalysisError.NO_ERRORS;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       return null;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   DartEntryImpl get writableCopy {
@@ skipping 21 matching lines @@
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       return _parsedUnitState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return _publicNamespaceState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
       return _scanErrorsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKindState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
       return _tokenStreamState == CacheState.INVALID;
-    } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
+    } else if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS) || identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       DartEntryImpl_ResolutionState state = _resolutionState;
       while (state != null) {
-        if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
+        if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS)) {
+          return state._buildElementErrorsState == CacheState.INVALID;
+        } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrorsState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnitState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrorsState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hintsState == CacheState.INVALID;
         }
       }
       return false;
@@ skipping 338 matching lines @@
    * Set the state of the data represented by the given descriptor in the context of the given
    * library to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param cacheState the new state of the data represented by the given descriptor
    */
   void setStateInLibrary(DataDescriptor descriptor, Source librarySource, CacheState cacheState) {
     DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
+    if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS)) {
+      state._buildElementErrors = updatedValue(cacheState, state._buildElementErrors, AnalysisError.NO_ERRORS);
+      state._buildElementErrorsState = cacheState;
+    } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = updatedValue(cacheState, state._resolutionErrors, AnalysisError.NO_ERRORS);
       state._resolutionErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = updatedValue(cacheState, state._resolvedUnit, null);
       state._resolvedUnitState = cacheState;
     } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
       state._verificationErrors = updatedValue(cacheState, state._verificationErrors, AnalysisError.NO_ERRORS);
       state._verificationErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = updatedValue(cacheState, state._hints, AnalysisError.NO_ERRORS);
@@ skipping 53 matching lines @@
    * Set the value of the data represented by the given descriptor in the context of the given
    * library to the given value, and set the state of that data to [CacheState#VALID].
    *
    * @param descriptor the descriptor representing which data is to have its value set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param value the new value of the data represented by the given descriptor and library
    */
   void setValueInLibrary(DataDescriptor descriptor, Source librarySource, Object value) {
     DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
+    if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS)) {
+      state._buildElementErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
+      state._buildElementErrorsState = CacheState.VALID;
+    } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._resolutionErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = value as CompilationUnit;
       state._resolvedUnitState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
       state._verificationErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._verificationErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
@@ skipping 139 matching lines @@
   DartEntryImpl_ResolutionState _nextState;
 
   /**
    * The source for the defining compilation unit of the library that contains this unit. If this
    * unit is the defining compilation unit for it's library, then this will be the source for this
    * unit.
    */
   Source _librarySource;
 
   /**
+   * The state of the cached errors reported while building an element model.
+   */
+  CacheState _buildElementErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while building an element model, or an empty array if the errors are not
+   * currently cached.
+   */
+  List<AnalysisError> _buildElementErrors = AnalysisError.NO_ERRORS;
+
+  /**
    * The state of the cached resolved compilation unit.
    */
   CacheState _resolvedUnitState = CacheState.INVALID;
 
   /**
    * The resolved compilation unit, or `null` if the resolved compilation unit is not
    * currently cached.
    */
   CompilationUnit _resolvedUnit;
 
@@ skipping 31 matching lines @@
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   /**
    * Set this state to be exactly like the given state, recursively copying the next state as
    * necessary.
    *
    * @param other the state to be copied
    */
   void copyFrom(DartEntryImpl_ResolutionState other) {
     _librarySource = other._librarySource;
+    _buildElementErrorsState = other._buildElementErrorsState;
+    _buildElementErrors = other._buildElementErrors;
     _resolvedUnitState = other._resolvedUnitState;
     _resolvedUnit = other._resolvedUnit;
     _resolutionErrorsState = other._resolutionErrorsState;
     _resolutionErrors = other._resolutionErrors;
     _verificationErrorsState = other._verificationErrorsState;
     _verificationErrors = other._verificationErrors;
     _hintsState = other._hintsState;
     _hints = other._hints;
     if (other._nextState != null) {
       _nextState = new DartEntryImpl_ResolutionState();
       _nextState.copyFrom(other._nextState);
     }
   }
 
   /**
    * Flush any AST structures being maintained by this state.
    */
   void flushAstStructures() {
     if (_resolvedUnitState == CacheState.VALID) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
     }
     if (_nextState != null) {
       _nextState.flushAstStructures();
     }
   }
 
-  bool get hasErrorState => _resolvedUnitState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _verificationErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || (_nextState != null && _nextState.hasErrorState);
+  bool get hasErrorState => _buildElementErrorsState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _verificationErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || (_nextState != null && _nextState.hasErrorState);
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     _nextState = null;
     _librarySource = null;
+    _buildElementErrorsState = CacheState.INVALID;
+    _buildElementErrors = AnalysisError.NO_ERRORS;
     _resolvedUnitState = CacheState.INVALID;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _verificationErrorsState = CacheState.INVALID;
     _verificationErrors = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all resolution-based information as being in error, but
    * will not change the state of any parse results.
    */
   void recordResolutionError() {
+    _buildElementErrorsState = CacheState.ERROR;
+    _buildElementErrors = AnalysisError.NO_ERRORS;
     _resolvedUnitState = CacheState.ERROR;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.ERROR;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _verificationErrorsState = CacheState.ERROR;
     _verificationErrors = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.ERROR;
     _hints = AnalysisError.NO_ERRORS;
     if (_nextState != null) {
       _nextState.recordResolutionError();
     }
   }
 
   /**
    * Record that an in-process parse has stopped without recording results because the results
    * were invalidated before they could be recorded.
    */
   void recordResolutionNotInProcess() {
+    if (_buildElementErrorsState == CacheState.IN_PROCESS) {
+      _buildElementErrorsState = CacheState.INVALID;
+    }
     if (_resolvedUnitState == CacheState.IN_PROCESS) {
       _resolvedUnitState = CacheState.INVALID;
     }
     if (_resolutionErrorsState == CacheState.IN_PROCESS) {
       _resolutionErrorsState = CacheState.INVALID;
     }
     if (_verificationErrorsState == CacheState.IN_PROCESS) {
       _verificationErrorsState = CacheState.INVALID;
     }
     if (_hintsState == CacheState.IN_PROCESS) {
       _hintsState = CacheState.INVALID;
     }
     if (_nextState != null) {
       _nextState.recordResolutionNotInProcess();
     }
   }
 
   /**
    * Write a textual representation of this state to the given builder. The result will only be
    * used for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void writeOn(JavaStringBuilder builder) {
     if (_librarySource != null) {
+      builder.append("; buildElementErrors = ");
+      builder.append(_buildElementErrorsState);
       builder.append("; resolvedUnit = ");
       builder.append(_resolvedUnitState);
       builder.append("; resolutionErrors = ");
       builder.append(_resolutionErrorsState);
       builder.append("; verificationErrors = ");
       builder.append(_verificationErrorsState);
       builder.append("; hints = ");
       builder.append(_hintsState);
       if (_nextState != null) {
         _nextState.writeOn(builder);
@@ skipping 80 matching lines @@
    * The data descriptor representing the list of referenced libraries.
    */
   static final DataDescriptor<List<Source>> REFERENCED_LIBRARIES = new DataDescriptor<List<Source>>("HtmlEntry.REFERENCED_LIBRARIES");
 
   /**
    * The data descriptor representing the errors resulting from resolving the source.
    */
   static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.RESOLUTION_ERRORS");
 
   /**
+   * The data descriptor representing the status of Polymer elements in the source.
+   */
+  static final DataDescriptor<List<AnalysisError>> POLYMER_BUILD_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.POLYMER_BUILD_ERRORS");
+
+  /**
+   * The data descriptor representing the errors reported during Polymer resolution.
+   */
+  static final DataDescriptor<List<AnalysisError>> POLYMER_RESOLUTION_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.POLYMER_RESOLUTION_ERRORS");
+
+  /**
    * Return all of the errors associated with the compilation unit that are currently cached.
    *
    * @return all of the errors associated with the compilation unit
    */
   List<AnalysisError> get allErrors;
 
   /**
    * Return a valid parsed unit, either an unresolved AST structure or the result of resolving the
    * AST structure, or `null` if there is no parsed unit available.
    *
@@ skipping 118 matching lines @@
    */
   CacheState _hintsState = CacheState.INVALID;
 
   /**
    * The hints produced while auditing the compilation unit, or an empty array if the hints are not
    * currently cached.
    */
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   /**
+   * The state of the Polymer elements.
+   */
+  CacheState _polymerBuildErrorsState = CacheState.INVALID;
+
+  /**
+   * The hints produced while performing Polymer HTML elements building, or an empty array if the
+   * error are not currently cached.
+   */
+  List<AnalysisError> _polymerBuildErrors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The state of the Polymer resolution errors.
+   */
+  CacheState _polymerResolutionErrorsState = CacheState.INVALID;
+
+  /**
+   * The hints produced while performing Polymer resolution, or an empty array if the error are not
+   * currently cached.
+   */
+  List<AnalysisError> _polymerResolutionErrors = AnalysisError.NO_ERRORS;
+
+  /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
     if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnit = null;
     }
     if (_resolvedUnitState == CacheState.VALID) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
@@ skipping 22 matching lines @@
     if (_angularErrors != null) {
       for (AnalysisError error in _angularErrors) {
         errors.add(error);
       }
     }
     if (_hints != null) {
       for (AnalysisError error in _hints) {
         errors.add(error);
       }
     }
+    if (_polymerBuildErrors != null) {
+      for (AnalysisError error in _polymerBuildErrors) {
+        errors.add(error);
+      }
+    }
+    if (_polymerResolutionErrors != null) {
+      for (AnalysisError error in _polymerResolutionErrors) {
+        errors.add(error);
+      }
+    }
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
   @override
   ht.HtmlUnit get anyParsedUnit {
     if (_parsedUnitState == CacheState.VALID) {
       //      parsedUnitAccessed = true;
@@ skipping 26 matching lines @@
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnitState;
     } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
       return _resolvedUnitState;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibrariesState;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrorsState;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       return _hintsState;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_BUILD_ERRORS)) {
+      return _polymerBuildErrorsState;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_RESOLUTION_ERRORS)) {
+      return _polymerResolutionErrorsState;
     }
     return super.getState(descriptor);
   }
 
   @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       return _angularApplication;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       return _angularComponent;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ENTRY)) {
       return _angularEntry;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ERRORS)) {
       return _angularErrors;
     } else if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _element;
     } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
       return _parseErrors;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnit;
     } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
       return _resolvedUnit;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibraries;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrors;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       return _hints;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_BUILD_ERRORS)) {
+      return _polymerBuildErrors;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_RESOLUTION_ERRORS)) {
+      return _polymerResolutionErrors;
     }
     return super.getValue(descriptor);
   }
 
   @override
   HtmlEntryImpl get writableCopy {
     HtmlEntryImpl copy = new HtmlEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
@@ skipping 13 matching lines @@
   }
 
   /**
    * Invalidate all of the resolution information associated with the HTML file.
    */
   void invalidateAllResolutionInformation() {
     _angularEntry = null;
     _angularEntryState = CacheState.INVALID;
     _angularErrors = AnalysisError.NO_ERRORS;
     _angularErrorsState = CacheState.INVALID;
+    _polymerBuildErrors = AnalysisError.NO_ERRORS;
+    _polymerBuildErrorsState = CacheState.INVALID;
+    _polymerResolutionErrors = AnalysisError.NO_ERRORS;
+    _polymerResolutionErrorsState = CacheState.INVALID;
     _element = null;
     _elementState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _resolutionErrorsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
   }
 
   @override
   void recordContentError() {
@@ skipping 16 matching lines @@
   /**
    * Record that an error was encountered while attempting to resolve the source associated with
    * this entry.
    */
   void recordResolutionError() {
     setState(HtmlEntry.ANGULAR_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.RESOLVED_UNIT, CacheState.ERROR);
     setState(HtmlEntry.ELEMENT, CacheState.ERROR);
     setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.HINTS, CacheState.ERROR);
+    setState(HtmlEntry.POLYMER_BUILD_ERRORS, CacheState.ERROR);
+    setState(HtmlEntry.POLYMER_RESOLUTION_ERRORS, CacheState.ERROR);
   }
 
   @override
   void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       _angularApplication = updatedValue(state, _angularApplication, null);
       _angularApplicationState = state;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       _angularComponent = updatedValue(state, _angularComponent, null);
       _angularComponentState = state;
@@ skipping 17 matching lines @@
       _resolvedUnitState = state;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       _referencedLibraries = updatedValue(state, _referencedLibraries, Source.EMPTY_ARRAY);
       _referencedLibrariesState = state;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       _resolutionErrors = updatedValue(state, _resolutionErrors, AnalysisError.NO_ERRORS);
       _resolutionErrorsState = state;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       _hints = updatedValue(state, _hints, AnalysisError.NO_ERRORS);
       _hintsState = state;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_BUILD_ERRORS)) {
+      _polymerBuildErrors = updatedValue(state, _polymerBuildErrors, null);
+      _polymerBuildErrorsState = state;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_RESOLUTION_ERRORS)) {
+      _polymerResolutionErrors = updatedValue(state, _polymerResolutionErrors, null);
+      _polymerResolutionErrorsState = state;
     } else {
       super.setState(descriptor, state);
     }
   }
 
   @override
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       _angularApplication = value as AngularApplication;
       _angularApplicationState = CacheState.VALID;
@@ skipping 20 matching lines @@
       _resolvedUnitState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       _referencedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _referencedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       _resolutionErrors = value as List<AnalysisError>;
       _resolutionErrorsState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       _hints = value as List<AnalysisError>;
       _hintsState = CacheState.VALID;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_BUILD_ERRORS)) {
+      _polymerBuildErrors = value as List<AnalysisError>;
+      _polymerBuildErrorsState = CacheState.VALID;
+    } else if (identical(descriptor, HtmlEntry.POLYMER_RESOLUTION_ERRORS)) {
+      _polymerResolutionErrors = value as List<AnalysisError>;
+      _polymerResolutionErrorsState = CacheState.VALID;
     } else {
       super.setValue(descriptor, value);
     }
   }
 
   @override
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     HtmlEntryImpl other = entry as HtmlEntryImpl;
     _angularApplicationState = other._angularApplicationState;
     _angularApplication = other._angularApplication;
     _angularComponentState = other._angularComponentState;
     _angularComponent = other._angularComponent;
     _angularEntryState = other._angularEntryState;
     _angularEntry = other._angularEntry;
     _angularErrorsState = other._angularErrorsState;
     _angularErrors = other._angularErrors;
     _parseErrorsState = other._parseErrorsState;
     _parseErrors = other._parseErrors;
     _parsedUnitState = other._parsedUnitState;
     _parsedUnit = other._parsedUnit;
     _resolvedUnitState = other._resolvedUnitState;
     _resolvedUnit = other._resolvedUnit;
     _referencedLibrariesState = other._referencedLibrariesState;
     _referencedLibraries = other._referencedLibraries;
+    _resolutionErrorsState = other._resolutionErrorsState;
     _resolutionErrors = other._resolutionErrors;
-    _resolutionErrorsState = other._resolutionErrorsState;
     _elementState = other._elementState;
     _element = other._element;
+    _hintsState = other._hintsState;
     _hints = other._hints;
-    _hintsState = other._hintsState;
+    _polymerBuildErrorsState = other._polymerBuildErrorsState;
+    _polymerBuildErrors = other._polymerBuildErrors;
+    _polymerResolutionErrorsState = other._polymerResolutionErrorsState;
+    _polymerResolutionErrors = other._polymerResolutionErrors;
   }
 
   @override
-  bool get hasErrorState => super.hasErrorState || _parsedUnitState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _referencedLibrariesState == CacheState.ERROR || _elementState == CacheState.ERROR || _angularErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR;
+  bool get hasErrorState => super.hasErrorState || _parsedUnitState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _referencedLibrariesState == CacheState.ERROR || _elementState == CacheState.ERROR || _angularErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || _polymerBuildErrorsState == CacheState.ERROR || _polymerResolutionErrorsState == CacheState.ERROR;
 
   @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Html: ");
     super.writeOn(builder);
     builder.append("; parseErrors = ");
     builder.append(_parseErrorsState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append("; resolvedUnit = ");
     builder.append(_resolvedUnitState);
     builder.append("; resolutionErrors = ");
     builder.append(_resolutionErrorsState);
     builder.append("; referencedLibraries = ");
     builder.append(_referencedLibrariesState);
     builder.append("; element = ");
     builder.append(_elementState);
     builder.append("; angularApplication = ");
     builder.append(_angularApplicationState);
     builder.append("; angularComponent = ");
     builder.append(_angularComponentState);
     builder.append("; angularEntry = ");
     builder.append(_angularEntryState);
     builder.append("; angularErrors = ");
     builder.append(_angularErrorsState);
+    builder.append("; polymerBuildErrors = ");
+    builder.append(_polymerBuildErrorsState);
+    builder.append("; polymerResolutionErrors = ");
+    builder.append(_polymerResolutionErrorsState);
   }
 }
 
 /**
  * The enumerated type `RetentionPriority` represents the priority of data in the cache in
  * terms of the desirability of retaining some specified data about a specified source.
  */
 class RetentionPriority extends Enum<RetentionPriority> {
   /**
    * A priority indicating that a given piece of data can be removed from the cache without
@@ skipping 620 matching lines @@
     for (Source source in removedSources) {
       _sourceRemoved(source);
     }
     if (addedDartSource) {
       // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
       // that might have been referencing the not-yet-existing source that was just added. Longer
       // term we need to keep track of which libraries are referencing non-existing sources and
       // only re-analyze those libraries.
       //        logInformation("Added Dart sources, invalidating all resolution information");
       List<Source> sourcesToInvalidate = new List<Source>();
-      for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
-        Source source = mapEntry.getKey();
-        SourceEntry sourceEntry = mapEntry.getValue();
+      MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+      while (iterator.moveNext()) {
+        Source source = iterator.key;
+        SourceEntry sourceEntry = iterator.value;
         if (!source.isInSystemLibrary && sourceEntry is DartEntry) {
           sourcesToInvalidate.add(source);
         }
       }
       int count = sourcesToInvalidate.length;
       for (int i = 0; i < count; i++) {
         Source source = sourcesToInvalidate[i];
         DartEntry dartEntry = _getReadableDartEntry(source);
         _removeFromParts(source, dartEntry);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
@@ skipping 171 matching lines @@
     return source.exists();
   }
 
   @override
   AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext);
 
   @override
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) {
     List<Source> sourcesToRemove = new List<Source>();
     // Move sources in the specified directory to the new context
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      Source source = entry.getKey();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      Source source = iterator.key;
+      SourceEntry sourceEntry = iterator.value;
       if (container.contains(source)) {
         sourcesToRemove.add(source);
-        newContext.addSourceInfo(source, entry.getValue().writableCopy);
+        newContext.addSourceInfo(source, sourceEntry.writableCopy);
       }
     }
     return newContext;
   }
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   AngularApplication getAngularApplicationWithHtml(Source htmlSource) {
@@ skipping 82 matching lines @@
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
       return Source.EMPTY_ARRAY;
     }
     List<Source> htmlSources = new List<Source>();
     while (true) {
       if (sourceKind == SourceKind.LIBRARY) {
       } else if (sourceKind == SourceKind.PART) {
         List<Source> librarySources = getLibrariesContaining(source);
-        for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-          SourceEntry sourceEntry = entry.getValue();
+        MapIterator<Source, SourceEntry> partIterator = _cache.iterator();
+        while (partIterator.moveNext()) {
+          SourceEntry sourceEntry = partIterator.value;
           if (sourceEntry.kind == SourceKind.HTML) {
             List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_containsAny(referencedLibraries, librarySources)) {
-              htmlSources.add(entry.getKey());
+              htmlSources.add(partIterator.key);
             }
           }
         }
       }
       break;
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(htmlSources);
   }
 
   @override
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   @override
   SourceKind getKindOf(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
 
   @override
   List<Source> get launchableClientLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that do not reference dart:html,
     // either directly or indirectly.
     List<Source> sources = new List<Source>();
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      Source source = entry.getKey();
-      SourceEntry sourceEntry = entry.getValue();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      Source source = iterator.key;
+      SourceEntry sourceEntry = iterator.value;
       if (sourceEntry.kind == SourceKind.LIBRARY && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   @override
   List<Source> get launchableServerLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that reference dart:html, either
     // directly or indirectly.
     List<Source> sources = new List<Source>();
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      Source source = entry.getKey();
-      SourceEntry sourceEntry = entry.getValue();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      Source source = iterator.key;
+      SourceEntry sourceEntry = iterator.value;
       if (sourceEntry.kind == SourceKind.LIBRARY && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && !dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   @override
   List<Source> getLibrariesContaining(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
     }
     return Source.EMPTY_ARRAY;
   }
 
   @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      SourceEntry sourceEntry = entry.getValue();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      SourceEntry sourceEntry = iterator.value;
       if (sourceEntry.kind == SourceKind.LIBRARY) {
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
-          dependentLibraries.add(entry.getKey());
+          dependentLibraries.add(iterator.key);
         }
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
-          dependentLibraries.add(entry.getKey());
+          dependentLibraries.add(iterator.key);
         }
       }
     }
     if (dependentLibraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(dependentLibraries);
   }
 
   @override
@@ skipping 62 matching lines @@
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
   @override
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      SourceEntry sourceEntry = entry.getValue();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is DartEntry) {
         if (!sourceEntry.isRefactoringSafe) {
-          sources.add(entry.getKey());
+          sources.add(iterator.key);
         }
       }
     }
     return new List.from(sources);
   }
 
   @override
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
@@ skipping 35 matching lines @@
     bool hintsEnabled = _options.hint;
     //
     // Look for priority sources that need to be analyzed.
     //
     for (Source source in _priorityOrder) {
       _getSourcesNeedingProcessing(source, _cache.get(source), true, hintsEnabled, sources);
     }
     //
     // Look for non-priority sources that need to be analyzed.
     //
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      _getSourcesNeedingProcessing(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      _getSourcesNeedingProcessing(iterator.key, iterator.value, false, hintsEnabled, sources);
     }
     return new List<Source>.from(sources);
   }
 
   @override
   AnalysisContentStatistics get statistics {
     bool hintsEnabled = _options.hint;
     AnalysisContentStatisticsImpl statistics = new AnalysisContentStatisticsImpl();
-    for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
-      statistics.addSource(mapEntry.getKey());
-      SourceEntry entry = mapEntry.getValue();
-      if (entry is DartEntry) {
-        Source source = mapEntry.getKey();
-        DartEntry dartEntry = entry;
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      SourceEntry sourceEntry = iterator.value;
+      if (sourceEntry is DartEntry) {
+        Source source = iterator.key;
+        DartEntry dartEntry = sourceEntry;
         SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
         // get library independent values
         statistics.putCacheItem(dartEntry, SourceEntry.LINE_INFO);
         statistics.putCacheItem(dartEntry, DartEntry.PARSE_ERRORS);
         statistics.putCacheItem(dartEntry, DartEntry.PARSED_UNIT);
         statistics.putCacheItem(dartEntry, DartEntry.SOURCE_KIND);
         if (kind == SourceKind.LIBRARY) {
           statistics.putCacheItem(dartEntry, DartEntry.ELEMENT);
           statistics.putCacheItem(dartEntry, DartEntry.EXPORTED_LIBRARIES);
           statistics.putCacheItem(dartEntry, DartEntry.IMPORTED_LIBRARIES);
           statistics.putCacheItem(dartEntry, DartEntry.INCLUDED_PARTS);
           statistics.putCacheItem(dartEntry, DartEntry.IS_CLIENT);
           statistics.putCacheItem(dartEntry, DartEntry.IS_LAUNCHABLE);
         }
         // get library-specific values
         List<Source> librarySources = getLibrariesContaining(source);
         for (Source librarySource in librarySources) {
           statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
           statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
           if (_generateSdkErrors || !source.isInSystemLibrary) {
             statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
             if (hintsEnabled) {
               statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.HINTS);
             }
           }
         }
-      } else if (entry is HtmlEntry) {
-        HtmlEntry htmlEntry = entry;
+      } else if (sourceEntry is HtmlEntry) {
+        HtmlEntry htmlEntry = sourceEntry;
         statistics.putCacheItem(htmlEntry, SourceEntry.LINE_INFO);
         statistics.putCacheItem(htmlEntry, HtmlEntry.PARSE_ERRORS);
         statistics.putCacheItem(htmlEntry, HtmlEntry.PARSED_UNIT);
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLVED_UNIT);
       }
     }
     return statistics;
   }
 
@@ skipping 28 matching lines @@
 
   @override
   void mergeContext(AnalysisContext context) {
     if (context is InstrumentedAnalysisContextImpl) {
       context = (context as InstrumentedAnalysisContextImpl).basis;
     }
     if (context is! AnalysisContextImpl) {
       return;
     }
     // TODO(brianwilkerson) This does not lock against the other context's cacheLock.
-    for (MapEntry<Source, SourceEntry> entry in (context as AnalysisContextImpl)._cache.entrySet()) {
-      Source newSource = entry.getKey();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      Source newSource = iterator.key;
       SourceEntry existingEntry = _getReadableSourceEntry(newSource);
       if (existingEntry == null) {
         // TODO(brianwilkerson) Decide whether we really need to copy the info.
-        _cache.put(newSource, entry.getValue().writableCopy);
+        _cache.put(newSource, iterator.value.writableCopy);
       } else {
       }
     }
   }
 
   @override
   CompilationUnit parseCompilationUnit(Source source) => _getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
   @override
   ht.HtmlUnit parseHtmlUnit(Source source) => _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
@@ skipping 34 matching lines @@
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
     return new AnalysisResult(_getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
-    for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
-      Source librarySource = entry.getKey();
-      LibraryElement library = entry.getValue();
+    for (MapIterator<Source, LibraryElement> iter = SingleMapIterator.forMap(elementMap); iter.moveNext();) {
+      Source librarySource = iter.key;
+      LibraryElement library = iter.value;
       //
       // Cache the element in the library's info.
       //
       DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
-        _recordElementData(dartEntry, dartCopy, library, library.source, htmlSource);
+        _recordElementData(dartCopy, library, library.source, htmlSource);
         _cache.put(librarySource, dartCopy);
       }
     }
   }
 
   @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
@@ skipping 164 matching lines @@
       }
       if (_allModificationTimesMatch(resolvedLibraries)) {
         Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
         RecordingErrorListener errorListener = resolver.errorListener;
         for (ResolvableLibrary library in resolvedLibraries) {
           Source librarySource = library.librarySource;
           for (Source source in library.compilationUnitSources) {
             CompilationUnit unit = library.getAST(source);
             List<AnalysisError> errors = errorListener.getErrorsForSource(source);
             LineInfo lineInfo = getLineInfo(source);
-            DartEntry dartEntry = _cache.get(source) as DartEntry;
-            int sourceTime = getModificationStamp(source);
-            if (dartEntry.modificationTime != sourceTime) {
-              // The source has changed without the context being notified. Simulate notification.
-              _sourceChanged(source);
-              dartEntry = _getReadableDartEntry(source);
-              if (dartEntry == null) {
-                throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
-              }
-            }
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
+            DartEntryImpl dartCopy = _cache.get(source).writableCopy as DartEntryImpl;
             if (thrownException == null) {
               dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
               dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
               dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
               dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
-                _recordElementData(dartEntry, dartCopy, library.libraryElement, librarySource, htmlSource);
+                _recordElementData(dartCopy, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
               dartCopy.recordResolutionError();
               _cache.remove(source);
             }
             dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
@@ skipping 104 matching lines @@
                 throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
               }
             }
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             if (thrownException == null) {
               dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
               dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
               dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
               dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
-                _recordElementData(dartEntry, dartCopy, library.libraryElement, librarySource, htmlSource);
+                _recordElementData(dartCopy, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
               dartCopy.recordResolutionError();
               _cache.remove(source);
             }
             dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
@@ skipping 68 matching lines @@
 
   /**
    * Add all of the sources contained in the given source container to the given list of sources.
    *
    * Note: This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param sources the list to which sources are to be added
    * @param container the source container containing the sources to be added to the list
    */
   void _addSourcesInContainer(List<Source> sources, SourceContainer container) {
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      Source source = entry.getKey();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      Source source = iterator.key;
       if (container.contains(source)) {
         sources.add(source);
       }
     }
   }
 
   /**
    * Return `true` if the modification times of the sources used by the given library resolver
    * to resolve one or more libraries are consistent with the modification times in the cache.
    *
@@ skipping 470 matching lines @@
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
     HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
     htmlCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     htmlCopy.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, htmlCopy);
     return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, htmlCopy.modificationTime, content), false);
   }
 
   /**
+   * Create a [PolymerBuildHtmlTask] for the given source, marking the Polymer elements as
+   * being in-process.
+   *
+   * @param source the source whose content is to be processed
+   * @param htmlEntry the entry for the source
+   * @return task data representing the created task
+   */
+  AnalysisContextImpl_TaskData _createPolymerBuildHtmlTask(Source source, HtmlEntry htmlEntry) {
+    if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
+      return _createResolveHtmlTask(source, htmlEntry);
+    }
+    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+    htmlCopy.setState(HtmlEntry.POLYMER_BUILD_ERRORS, CacheState.IN_PROCESS);
+    _cache.put(source, htmlCopy);
+    return new AnalysisContextImpl_TaskData(new PolymerBuildHtmlTask(this, source, htmlCopy.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+  }
+
+  /**
+   * Create a [PolymerResolveHtmlTask] for the given source, marking the Polymer errors as
+   * being in-process.
+   *
+   * @param source the source whose content is to be resolved
+   * @param htmlEntry the entry for the source
+   * @return task data representing the created task
+   */
+  AnalysisContextImpl_TaskData _createPolymerResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
+    if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
+      return _createResolveHtmlTask(source, htmlEntry);
+    }
+    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+    htmlCopy.setState(HtmlEntry.POLYMER_RESOLUTION_ERRORS, CacheState.IN_PROCESS);
+    _cache.put(source, htmlCopy);
+    return new AnalysisContextImpl_TaskData(new PolymerResolveHtmlTask(this, source, htmlCopy.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+  }
+
+  /**
    * Create a [ResolveAngularComponentTemplateTask] for the given source, marking the angular
    * errors as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveAngularComponentTemplateTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
@@ skipping 626 matching lines @@
         CacheState angularEntryState = htmlEntry.getState(HtmlEntry.ANGULAR_ENTRY);
         if (angularEntryState == CacheState.INVALID || (isPriority && angularEntryState == CacheState.FLUSHED)) {
           return _createResolveAngularEntryHtmlTask(source, htmlEntry);
         }
         // Try to resolve the HTML as an Angular application part.
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
         if (angularErrorsState == CacheState.INVALID || (isPriority && angularErrorsState == CacheState.FLUSHED)) {
           return _createResolveAngularComponentTemplateTask(source, htmlEntry);
         }
       }
+      //
+      // Polymer support
+      //
+      if (_options.analyzePolymer) {
+        // Build elements.
+        CacheState polymerBuildErrorsState = htmlEntry.getState(HtmlEntry.POLYMER_BUILD_ERRORS);
+        if (polymerBuildErrorsState == CacheState.INVALID || (isPriority && polymerBuildErrorsState == CacheState.FLUSHED)) {
+          return _createPolymerBuildHtmlTask(source, htmlEntry);
+        }
+        // Resolve references.
+        CacheState polymerResolutionErrorsState = htmlEntry.getState(HtmlEntry.POLYMER_RESOLUTION_ERRORS);
+        if (polymerResolutionErrorsState == CacheState.INVALID || (isPriority && polymerResolutionErrorsState == CacheState.FLUSHED)) {
+          return _createPolymerResolveHtmlTask(source, htmlEntry);
+        }
+      }
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Return a change notice for the given source, creating one if one does not already exist.
    *
    * @param source the source for which changes are being reported
    * @return a change notice for the given source
    */
@@ skipping 85 matching lines @@
   }
 
   /**
    * Return an array containing all of the sources known to this context that have the given kind.
    *
    * @param kind the kind of sources to be returned
    * @return all of the sources known to this context that have the given kind
    */
   List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      if (entry.getValue().kind == kind) {
-        sources.add(entry.getKey());
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      if (iterator.value.kind == kind) {
+        sources.add(iterator.key);
       }
     }
     return new List.from(sources);
   }
 
   /**
    * Look at the given source to see whether a task needs to be performed related to it. If so, add
    * the source to the set of sources that need to be processed. This method duplicates, and must
    * therefore be kept in sync with,
    * [getNextAnalysisTask]. This method is intended to
@@ skipping 86 matching lines @@
           AngularApplication applicationInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
           if (applicationInfo != null) {
             AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
             if (component != null) {
               sources.add(source);
               return;
             }
           }
         }
       }
+      // Polymer
+      if (_options.analyzePolymer) {
+        // Elements building.
+        CacheState polymerBuildErrorsState = htmlEntry.getState(HtmlEntry.POLYMER_BUILD_ERRORS);
+        if (polymerBuildErrorsState == CacheState.INVALID || (isPriority && polymerBuildErrorsState == CacheState.FLUSHED)) {
+          sources.add(source);
+        }
+        // Resolution.
+        CacheState polymerResolutionErrorsState = htmlEntry.getState(HtmlEntry.POLYMER_RESOLUTION_ERRORS);
+        if (polymerResolutionErrorsState == CacheState.INVALID || (isPriority && polymerResolutionErrorsState == CacheState.FLUSHED)) {
+          sources.add(source);
+        }
+      }
     }
   }
 
   /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
   void _invalidateAllResolutionInformation() {
     Map<Source, List<Source>> oldPartMap = new Map<Source, List<Source>>();
-    for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
-      Source source = mapEntry.getKey();
-      SourceEntry sourceEntry = mapEntry.getValue();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      Source source = iterator.key;
+      SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
-        mapEntry.setValue(htmlCopy);
+        iterator.value = htmlCopy;
       } else if (sourceEntry is DartEntry) {
         DartEntry dartEntry = sourceEntry;
         oldPartMap[source] = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.invalidateAllResolutionInformation();
-        mapEntry.setValue(dartCopy);
+        iterator.value = dartCopy;
         _workManager.add(source, SourcePriority.UNKNOWN);
       }
     }
     _removeFromPartsUsingMap(oldPartMap);
   }
 
   /**
    * In response to a change to Angular entry point [HtmlElement], invalidate any results that
    * depend on it.
    *
@@ skipping 179 matching lines @@
         // notify about Dart errors
         ChangeNoticeImpl notice = _getNotice(elementSource);
         notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
       }
     }
     // remember Angular entry point
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
+   * Record the results produced by performing a [BuildDartElementModelTask]. If the results
+   * were computed from data that is now out-of-date, then the results will not be recorded.
+   *
+   * @param task the task that was performed
+   * @return an entry containing the recorded results
+   * @throws AnalysisException if the results could not be recorded
+   */
+  DartEntry _recordBuildDartElementModelTask(BuildDartElementModelTask task) {
+    Source targetLibrary = task.targetLibrary;
+    List<ResolvableLibrary> builtLibraries = task.librariesInCycle;
+    AnalysisException thrownException = task.exception;
+    DartEntry targetEntry = null;
+    if (_allModificationTimesMatch(builtLibraries)) {
+      Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
+      RecordingErrorListener errorListener = task.errorListener;
+      for (ResolvableLibrary library in builtLibraries) {
+        Source librarySource = library.librarySource;
+        for (Source source in library.compilationUnitSources) {
+          CompilationUnit unit = library.getAST(source);
+          List<AnalysisError> errors = errorListener.getErrorsForSource(source);
+          LineInfo lineInfo = getLineInfo(source);
+          DartEntryImpl dartCopy = _cache.get(source).writableCopy as DartEntryImpl;
+          if (thrownException == null) {
+            dartCopy.setValueInLibrary(DartEntry.BUILD_ELEMENT_ERRORS, librarySource, errors);
+            if (source == librarySource) {
+              LibraryElementImpl libraryElement = library.libraryElement;
+              dartCopy.setValue(DartEntry.ELEMENT, libraryElement);
+              dartCopy.setValue(DartEntry.IS_LAUNCHABLE, libraryElement.entryPoint != null);
+              dartCopy.setValue(DartEntry.IS_CLIENT, _isClient(libraryElement, htmlSource, new Set<LibraryElement>()));
+            }
+          } else {
+            dartCopy.recordResolutionError();
+            _cache.remove(source);
+          }
+          dartCopy.exception = thrownException;
+          _cache.put(source, dartCopy);
+          if (source != librarySource) {
+            _workManager.add(librarySource, SourcePriority.PRIORITY_PART);
+          }
+          if (source == targetLibrary) {
+            targetEntry = dartCopy;
+          }
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.compilationUnit = unit;
+          notice.setErrors(dartCopy.allErrors, lineInfo);
+        }
+      }
+    } else {
+      PrintStringWriter writer = new PrintStringWriter();
+      writer.println("Build element model results discarded for");
+      for (ResolvableLibrary library in builtLibraries) {
+        for (Source source in library.compilationUnitSources) {
+          DartEntry dartEntry = _getReadableDartEntry(source);
+          if (dartEntry != null) {
+            int resultTime = library.getModificationTime(source);
+            writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
+            DartEntryImpl dartCopy = dartEntry.writableCopy;
+            if (thrownException == null || resultTime >= 0) {
+              //
+              // The analysis was performed on out-of-date sources. Mark the cache so that the
+              // sources will be re-analyzed using the up-to-date sources.
+              //
+              dartCopy.recordResolutionNotInProcess();
+            } else {
+              //
+              // We could not determine whether the sources were up-to-date or out-of-date. Mark
+              // the cache so that we won't attempt to re-analyze the sources until there's a
+              // good chance that we'll be able to do so without error.
+              //
+              dartCopy.recordResolutionError();
+              _cache.remove(source);
+            }
+            dartCopy.exception = thrownException;
+            _cache.put(source, dartCopy);
+            if (source == targetLibrary) {
+              targetEntry = dartCopy;
+            }
+          } else {
+            writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
+          }
+        }
+      }
+      _logInformation(writer.toString());
+    }
+    if (thrownException != null) {
+      throw thrownException;
+    }
+    if (targetEntry == null) {
+      targetEntry = _getReadableDartEntry(targetLibrary);
+      if (targetEntry == null) {
+        throw new AnalysisException.con1("A Dart file became a non-Dart file: ${targetLibrary.fullName}");
+      }
+    }
+    return targetEntry;
+  }
+
+  /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
-   * @param dartEntry the original cache entry from which the copy was made
    * @param dartCopy the cache entry in which data is to be recorded
    * @param library the library element used to record information
    * @param librarySource the source for the library used to record information
    * @param htmlSource the source for the HTML library
    */
-  void _recordElementData(DartEntry dartEntry, DartEntryImpl dartCopy, LibraryElement library, Source librarySource, Source htmlSource) {
+  void _recordElementData(DartEntryImpl dartCopy, LibraryElement library, Source librarySource, Source htmlSource) {
     dartCopy.setValue(DartEntry.ELEMENT, library);
     dartCopy.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
     dartCopy.setValue(DartEntry.IS_CLIENT, _isClient(library, htmlSource, new Set<LibraryElement>()));
   }
 
   /**
    * Record the results produced by performing a [GenerateDartErrorsTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
@@ skipping 94 matching lines @@
       }
       if (thrownException == null) {
         thrownException = new AnalysisException.con1("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}");
       }
       DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
       dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
       dartCopy.exception = thrownException;
       _cache.put(librarySource, dartCopy);
       throw thrownException;
     }
-    for (MapEntry<Source, TimestampedData<List<AnalysisError>>> entry in getMapEntrySet(hintMap)) {
-      Source unitSource = entry.getKey();
-      TimestampedData<List<AnalysisError>> results = entry.getValue();
+    for (MapIterator<Source, TimestampedData<List<AnalysisError>>> iter = SingleMapIterator.forMap(hintMap); iter.moveNext();) {
+      Source unitSource = iter.key;
+      TimestampedData<List<AnalysisError>> results = iter.value;
       SourceEntry sourceEntry = _cache.get(unitSource);
       if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
       }
       DartEntry dartEntry = sourceEntry as DartEntry;
       if (unitSource == librarySource) {
         libraryEntry = dartEntry;
       }
@@ skipping 310 matching lines @@
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
-   * Record the results produced by performing a [ResolveAngularComponentTemplateTask]. If the
-   * results were computed from data that is now out-of-date, then the results will not be recorded.
+   * Record the results produced by performing a [PolymerBuildHtmlTask]. If the results were
+   * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
-  HtmlEntry _recordResolveAngularComponentTemplateTaskResults(ResolveAngularComponentTemplateTask task) {
+  HtmlEntry _recordPolymerBuildHtmlTaskResults(PolymerBuildHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
-        htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
+        htmlCopy.setValue(HtmlEntry.POLYMER_BUILD_ERRORS, task.errors);
         // notify about errors
         ChangeNoticeImpl notice = _getNotice(source);
-        notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
-        //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
-        //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
-        //          }
-        //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
-        //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
-        //          }
-        //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
-        //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
-        //          }
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } else {
         //
         // We could not determine whether the sources were up-to-date or out-of-date. Mark the
         // cache so that we won't attempt to re-analyze the sources until there's a good chance
         // that we'll be able to do so without error.
         //
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
-   * Record the results produced by performing a [ResolveAngularEntryHtmlTask]. If the results
-   * were computed from data that is now out-of-date, then the results will not be recorded.
+   * Record the results produced by performing a [PolymerResolveHtmlTask]. If the results were
+   * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
-  HtmlEntry _recordResolveAngularEntryHtmlTaskResults(ResolveAngularEntryHtmlTask task) {
+  HtmlEntry _recordPolymerResolveHtmlTaskResults(PolymerResolveHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
-        htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
-        _recordAngularEntryPoint(htmlCopy, task);
-        _cache.storedAst(source);
+        htmlCopy.setValue(HtmlEntry.POLYMER_RESOLUTION_ERRORS, task.errors);
+        // notify about errors
         ChangeNoticeImpl notice = _getNotice(source);
-        notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
-        //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
-        //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
-        //          }
-        //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
-        //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
-        //          }
-        //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
-        //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
-        //          }
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } else {
         //
         // We could not determine whether the sources were up-to-date or out-of-date. Mark the
         // cache so that we won't attempt to re-analyze the sources until there's a good chance
         // that we'll be able to do so without error.
         //
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
+   * Record the results produced by performing a [ResolveAngularComponentTemplateTask]. If the
+   * results were computed from data that is now out-of-date, then the results will not be recorded.
+   *
+   * @param task the task that was performed
+   * @throws AnalysisException if the results could not be recorded
+   */
+  HtmlEntry _recordResolveAngularComponentTemplateTaskResults(ResolveAngularComponentTemplateTask task) {
+    Source source = task.source;
+    AnalysisException thrownException = task.exception;
+    HtmlEntry htmlEntry = null;
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! HtmlEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent an HTML file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    }
+    htmlEntry = sourceEntry as HtmlEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (htmlEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        _sourceChanged(source);
+        htmlEntry = _getReadableHtmlEntry(source);
+        if (htmlEntry == null) {
+          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+        }
+      }
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null) {
+        htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
+        // notify about errors
+        ChangeNoticeImpl notice = _getNotice(source);
+        notice.htmlUnit = task.resolvedUnit;
+        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+      } else {
+        htmlCopy.recordResolutionError();
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    } else {
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
+        //          }
+        htmlCopy.invalidateAllInformation();
+        htmlCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        htmlCopy.recordResolutionError();
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    }
+    if (thrownException != null) {
+      throw thrownException;
+    }
+    return htmlEntry;
+  }
+
+  /**
+   * Record the results produced by performing a [ResolveAngularEntryHtmlTask]. If the results
+   * were computed from data that is now out-of-date, then the results will not be recorded.
+   *
+   * @param task the task that was performed
+   * @throws AnalysisException if the results could not be recorded
+   */
+  HtmlEntry _recordResolveAngularEntryHtmlTaskResults(ResolveAngularEntryHtmlTask task) {
+    Source source = task.source;
+    AnalysisException thrownException = task.exception;
+    HtmlEntry htmlEntry = null;
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      throw new ObsoleteSourceAnalysisException(source);
+    } else if (sourceEntry is! HtmlEntry) {
+      // This shouldn't be possible because we should never have performed the task if the source
+      // didn't represent an HTML file, but check to be safe.
+      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+    }
+    htmlEntry = sourceEntry as HtmlEntry;
+    int sourceTime = getModificationStamp(source);
+    int resultTime = task.modificationTime;
+    if (sourceTime == resultTime) {
+      if (htmlEntry.modificationTime != sourceTime) {
+        // The source has changed without the context being notified. Simulate notification.
+        _sourceChanged(source);
+        htmlEntry = _getReadableHtmlEntry(source);
+        if (htmlEntry == null) {
+          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+        }
+      }
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null) {
+        htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
+        _recordAngularEntryPoint(htmlCopy, task);
+        _cache.storedAst(source);
+        ChangeNoticeImpl notice = _getNotice(source);
+        notice.htmlUnit = task.resolvedUnit;
+        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+      } else {
+        htmlCopy.recordResolutionError();
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    } else {
+      HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+      if (thrownException == null || resultTime >= 0) {
+        //
+        // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+        // will be re-analyzed using the up-to-date sources.
+        //
+        //          if (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
+        //          }
+        //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
+        //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
+        //          }
+        htmlCopy.invalidateAllInformation();
+        htmlCopy.modificationTime = sourceTime;
+        _cache.removedAst(source);
+      } else {
+        //
+        // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+        // cache so that we won't attempt to re-analyze the sources until there's a good chance
+        // that we'll be able to do so without error.
+        //
+        htmlCopy.recordResolutionError();
+      }
+      htmlCopy.exception = thrownException;
+      _cache.put(source, htmlCopy);
+      htmlEntry = htmlCopy;
+    }
+    if (thrownException != null) {
+      throw thrownException;
+    }
+    return htmlEntry;
+  }
+
+  /**
    * Record the results produced by performing a [ResolveDartUnitTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry _recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
     Source unitSource = task.source;
     Source librarySource = task.librarySource;
@@ skipping 258 matching lines @@
 
   /**
    * Remove the given libraries that are keys in the given map from the list of containing libraries
    * for each of the parts in the corresponding value.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param oldPartMap the table containing the parts associated with each library
    */
   void _removeFromPartsUsingMap(Map<Source, List<Source>> oldPartMap) {
-    for (MapEntry<Source, List<Source>> entry in getMapEntrySet(oldPartMap)) {
-      Source librarySource = entry.getKey();
-      List<Source> oldParts = entry.getValue();
+    for (MapIterator<Source, List<Source>> iter = SingleMapIterator.forMap(oldPartMap); iter.moveNext();) {
+      Source librarySource = iter.key;
+      List<Source> oldParts = iter.value;
       for (int i = 0; i < oldParts.length; i++) {
         Source partSource = oldParts[i];
         if (partSource != librarySource) {
           DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null) {
             DartEntryImpl partCopy = partEntry.writableCopy;
             partCopy.removeContainingLibrary(librarySource);
             if (partCopy.containingLibraries.length == 0 && !exists(partSource)) {
               _cache.remove(partSource);
             } else {
@@ skipping 128 matching lines @@
    * invalid so that the source will be re-analyzed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @return `true` if at least one entry was invalid
    */
   bool _validateCacheConsistency() {
     int consistencyCheckStart = JavaSystem.nanoTime();
     List<Source> changedSources = new List<Source>();
     List<Source> missingSources = new List<Source>();
-    for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      Source source = entry.getKey();
-      SourceEntry sourceEntry = entry.getValue();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      Source source = iterator.key;
+      SourceEntry sourceEntry = iterator.value;
       int sourceTime = getModificationStamp(source);
       if (sourceTime != sourceEntry.modificationTime) {
         changedSources.add(source);
       }
       if (sourceEntry.exception != null) {
         if (!exists(source)) {
           missingSources.add(source);
         }
       }
     }
@@ skipping 26 matching lines @@
 /**
  * Instances of the class `AnalysisTaskResultRecorder` are used by an analysis context to
  * record the results of a task.
  */
 class AnalysisContextImpl_AnalysisTaskResultRecorder implements AnalysisTaskVisitor<SourceEntry> {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
 
   @override
+  DartEntry visitBuildDartElementModelTask(BuildDartElementModelTask task) => AnalysisContextImpl_this._recordBuildDartElementModelTask(task);
+
+  @override
   DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this._recordGenerateDartErrorsTask(task);
 
   @override
   DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this._recordGenerateDartHintsTask(task);
 
   @override
   SourceEntry visitGetContentTask(GetContentTask task) => AnalysisContextImpl_this._recordGetContentsTask(task);
 
   @override
   DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this._recordIncrementalAnalysisTaskResults(task);
 
   @override
   DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this._recordParseDartTaskResults(task);
 
   @override
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this._recordParseHtmlTaskResults(task);
 
   @override
+  HtmlEntry visitPolymerBuildHtmlTask(PolymerBuildHtmlTask task) => AnalysisContextImpl_this._recordPolymerBuildHtmlTaskResults(task);
+
+  @override
+  HtmlEntry visitPolymerResolveHtmlTask(PolymerResolveHtmlTask task) => AnalysisContextImpl_this._recordPolymerResolveHtmlTaskResults(task);
+
+  @override
   HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task) => AnalysisContextImpl_this._recordResolveAngularComponentTemplateTaskResults(task);
 
   @override
   HtmlEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this._recordResolveAngularEntryHtmlTaskResults(task);
 
   @override
   DartEntry visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task) => AnalysisContextImpl_this.recordResolveDartLibraryCycleTaskResults(task);
 
   @override
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
@@ skipping 665 matching lines @@
    * A flag indicating whether analysis is to parse comments.
    */
   bool preserveComments = true;
 
   /**
    * A flag indicating whether analysis is to analyze Angular.
    */
   bool analyzeAngular = true;
 
   /**
+   * A flag indicating whether analysis is to analyze Polymer.
+   */
+  bool analyzePolymer = true;
+
+  /**
    * Initialize a newly created set of analysis options to have their default values.
    */
   AnalysisOptionsImpl();
 
   /**
    * Initialize a newly created set of analysis options to have the same values as those in the
    * given set of analysis options.
    *
    * @param options the analysis options whose values are being copied
    */
@@ skipping 1397 matching lines @@
    *          the elements representing the libraries
    */
   void recordLibraryElements(Map<Source, LibraryElement> elementMap);
 }
 
 /**
  * Container with global [AnalysisContext] performance statistics.
  */
 class PerformanceStatistics {
   /**
-   * The [TimeCounter] for time spent in Angular analysis.
-   */
-  static TimeCounter angular = new TimeCounter();
-
-  /**
    * The [TimeCounter] for time spent in reading files.
    */
   static TimeCounter io = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in scanning.
    */
   static TimeCounter scan = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in parsing.
    */
   static TimeCounter parse = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in resolving.
    */
   static TimeCounter resolve = new TimeCounter();
 
   /**
+   * The [TimeCounter] for time spent in Angular analysis.
+   */
+  static TimeCounter angular = new TimeCounter();
+
+  /**
+   * The [TimeCounter] for time spent in Polymer analysis.
+   */
+  static TimeCounter polymer = new TimeCounter();
+
+  /**
    * The [TimeCounter] for time spent in error verifier.
    */
   static TimeCounter errors = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in hints generator.
    */
   static TimeCounter hints = new TimeCounter();
 
   /**
    * Reset all of the time counters to zero.
    */
   static void reset() {
     io = new TimeCounter();
     scan = new TimeCounter();
     parse = new TimeCounter();
     resolve = new TimeCounter();
     angular = new TimeCounter();
+    polymer = new TimeCounter();
     errors = new TimeCounter();
     hints = new TimeCounter();
   }
 }
 
 /**
  * Instances of the class `RecordingErrorListener` implement an error listener that will
  * record the errors that are reported to it in a way that is appropriate for caching those errors
  * within an analysis context.
  */
@@ skipping 13 matching lines @@
       onError(error);
     }
   }
 
   /**
    * Answer the errors collected by the listener.
    *
    * @return an array of errors (not `null`, contains no `null`s)
    */
   List<AnalysisError> get errors {
-    Iterable<MapEntry<Source, Set<AnalysisError>>> entrySet = getMapEntrySet(_errors);
-    int numEntries = entrySet.length;
+    Iterable<Set<AnalysisError>> errorsSets = _errors.values;
+    int numEntries = errorsSets.length;
     if (numEntries == 0) {
       return AnalysisError.NO_ERRORS;
     }
     List<AnalysisError> resultList = new List<AnalysisError>();
-    for (MapEntry<Source, Set<AnalysisError>> entry in entrySet) {
-      resultList.addAll(entry.getValue());
+    for (Set<AnalysisError> errorsSet in errorsSets) {
+      resultList.addAll(errorsSet);
     }
     return new List.from(resultList);
   }
 
   /**
    * Answer the errors collected by the listener for some passed [Source].
    *
    * @param source some [Source] for which the caller wants the set of [AnalysisError]s
    *          collected by this listener
    * @return the errors collected by the listener for the passed [Source]
@@ skipping 1655 matching lines @@
   /**
    * Checks if this processor can be applied to the given [XmlTagNode].
    *
    * @param node the [XmlTagNode] to check
    * @return `true` if this processor can be applied, or `false` otherwise
    */
   bool canApply(ht.XmlTagNode node);
 }
 
 /**
+ * Instances of the class [PolymerHtmlUnitBuilder] build Polymer specific elements.
+ */
+class PolymerHtmlUnitBuilder extends ht.RecursiveXmlVisitor<Object> {
+  /**
+   * These names are forbidden to use as a custom tag name.
+   *
+   * http://w3c.github.io/webcomponents/spec/custom/#concepts
+   */
+  static Set<String> _FORBIDDEN_TAG_NAMES = new Set();
+
+  static bool isValidAttributeName(String name) {
+    // cannot be empty
+    if (name.isEmpty) {
+      return false;
+    }
+    // check characters
+    int length = name.length;
+    for (int i = 0; i < length; i++) {
+      int c = name.codeUnitAt(i);
+      if (i == 0) {
+        if (!Character.isLetter(c)) {
+          return false;
+        }
+      } else {
+        if (!(Character.isLetterOrDigit(c) || c == 0x5F)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  static bool isValidTagName(String name) {
+    // cannot be empty
+    if (name.isEmpty) {
+      return false;
+    }
+    // check for forbidden name
+    if (_FORBIDDEN_TAG_NAMES.contains(name)) {
+      return false;
+    }
+    // check characters
+    int length = name.length;
+    bool hasDash = false;
+    for (int i = 0; i < length; i++) {
+      int c = name.codeUnitAt(i);
+      // check for '-'
+      if (c == 0x2D) {
+        hasDash = true;
+      }
+      // check character
+      if (i == 0) {
+        if (hasDash) {
+          return false;
+        }
+        if (!Character.isLetter(c)) {
+          return false;
+        }
+      } else {
+        if (!(Character.isLetterOrDigit(c) || c == 0x2D || c == 0x5F)) {
+          return false;
+        }
+      }
+    }
+    if (!hasDash) {
+      return false;
+    }
+    return true;
+  }
+
+  final InternalAnalysisContext _context;
+
+  TypeProvider _typeProvider;
+
+  final AnalysisErrorListener _errorListener;
+
+  final Source _source;
+
+  final LineInfo _lineInfo;
+
+  final ht.HtmlUnit _unit;
+
+  List<PolymerTagHtmlElement> _tagHtmlElements = [];
+
+  ht.XmlTagNode _elementNode;
+
+  String _elementName;
+
+  PolymerTagHtmlElementImpl _htmlElement;
+
+  PolymerTagDartElementImpl _dartElement;
+
+  PolymerHtmlUnitBuilder(this._context, this._errorListener, this._source, this._lineInfo, this._unit) {
+    this._typeProvider = _context.typeProvider;
+  }
+
+  /**
+   * Builds Polymer specific HTML elements.
+   */
+  void build() {
+    _unit.accept(this);
+    // set Polymer tags
+    HtmlElementImpl unitElement = _unit.element as HtmlElementImpl;
+    unitElement.polymerTags = new List.from(_tagHtmlElements);
+  }
+
+  @override
+  Object visitXmlTagNode(ht.XmlTagNode node) {
+    if (node.tag == "polymer-element") {
+      _createTagHtmlElement(node);
+    }
+    // visit children
+    return super.visitXmlTagNode(node);
+  }
+
+  void _createAttributeElements() {
+    // prepare "attributes" attribute
+    ht.XmlAttributeNode attributesAttribute = _elementNode.getAttribute("attributes");
+    if (attributesAttribute == null) {
+      return;
+    }
+    // check if there is a Dart part to resolve against it
+    if (_dartElement == null) {
+      // TODO(scheglov) maybe report error (if it is allowed at all to have element without Dart part)
+      return;
+    }
+    // prepare value of the "attributes" attribute
+    String attributesText = attributesAttribute.text;
+    if (attributesText.trim().isEmpty) {
+      _reportErrorForAttribute(attributesAttribute, PolymerCode.EMPTY_ATTRIBUTES, []);
+      return;
+    }
+    // prepare attribute name tokens
+    List<PolymerHtmlUnitBuilder_NameToken> nameTokens = [];
+    {
+      int index = 0;
+      int textOffset = attributesAttribute.textOffset;
+      int nameOffset = -1;
+      JavaStringBuilder nameBuilder = new JavaStringBuilder();
+      while (index < attributesText.length) {
+        int c = attributesText.codeUnitAt(index++);
+        if (Character.isWhitespace(c)) {
+          if (nameOffset != -1) {
+            nameTokens.add(new PolymerHtmlUnitBuilder_NameToken(nameOffset, nameBuilder.toString()));
+            nameBuilder = new JavaStringBuilder();
+            nameOffset = -1;
+          }
+          continue;
+        }
+        if (nameOffset == -1) {
+          nameOffset = textOffset + index - 1;
+        }
+        nameBuilder.appendChar(c);
+      }
+      if (nameOffset != -1) {
+        nameTokens.add(new PolymerHtmlUnitBuilder_NameToken(nameOffset, nameBuilder.toString()));
+        nameBuilder = new JavaStringBuilder();
+      }
+    }
+    // create attributes for name tokens
+    List<PolymerAttributeElement> attributes = [];
+    Set<String> definedNames = new Set();
+    ClassElement classElement = _dartElement.classElement;
+    for (PolymerHtmlUnitBuilder_NameToken nameToken in nameTokens) {
+      int offset = nameToken._offset;
+      // prepare name
+      String name = nameToken._value;
+      if (!isValidAttributeName(name)) {
+        _reportErrorForNameToken(nameToken, PolymerCode.INVALID_ATTRIBUTE_NAME, [name]);
+        continue;
+      }
+      if (!definedNames.add(name)) {
+        _reportErrorForNameToken(nameToken, PolymerCode.DUPLICATE_ATTRIBUTE_DEFINITION, [name]);
+        continue;
+      }
+      // create attribute
+      PolymerAttributeElementImpl attribute = new PolymerAttributeElementImpl(name, offset);
+      attributes.add(attribute);
+      // resolve field
+      FieldElement field = classElement.getField(name);
+      if (field == null) {
+        _reportErrorForNameToken(nameToken, PolymerCode.UNDEFINED_ATTRIBUTE_FIELD, [name, classElement.displayName]);
+        continue;
+      }
+      if (!_isPublishedField(field)) {
+        _reportErrorForNameToken(nameToken, PolymerCode.ATTRIBUTE_FIELD_NOT_PUBLISHED, [name, classElement.displayName]);
+      }
+      attribute.field = field;
+    }
+    _htmlElement.attributes = new List.from(attributes);
+  }
+
+  void _createTagHtmlElement(ht.XmlTagNode node) {
+    this._elementNode = node;
+    this._elementName = null;
+    this._htmlElement = null;
+    this._dartElement = null;
+    // prepare 'name' attribute
+    ht.XmlAttributeNode nameAttribute = node.getAttribute("name");
+    if (nameAttribute == null) {
+      _reportErrorForToken(node.tagToken, PolymerCode.MISSING_TAG_NAME, []);
+      return;
+    }
+    // prepare name
+    _elementName = nameAttribute.text;
+    if (!isValidTagName(_elementName)) {
+      _reportErrorForAttributeValue(nameAttribute, PolymerCode.INVALID_TAG_NAME, [_elementName]);
+      return;
+    }
+    // TODO(scheglov) Maybe check that at least one of "template" or "script" children.
+    // TODO(scheglov) Maybe check if more than one top-level "template".
+    // create HTML element
+    int nameOffset = nameAttribute.textOffset;
+    _htmlElement = new PolymerTagHtmlElementImpl(_elementName, nameOffset);
+    // bind to the corresponding Dart element
+    _dartElement = _findTagDartElement();
+    if (_dartElement != null) {
+      _htmlElement.dartElement = _dartElement;
+      _dartElement.htmlElement = _htmlElement;
+    }
+    // TODO(scheglov) create attributes
+    _createAttributeElements();
+    // done
+    _tagHtmlElements.add(_htmlElement);
+  }
+
+  /**
+   * Returns the [PolymerTagDartElement] that corresponds to the Polymer custom tag declared
+   * by the given [XmlTagNode].
+   */
+  PolymerTagDartElementImpl _findTagDartElement() {
+    LibraryElement dartLibraryElement = dartUnitElement;
+    if (dartLibraryElement == null) {
+      return null;
+    }
+    return _findTagDartElement_inLibrary(dartLibraryElement);
+  }
+
+  /**
+   * Returns the [PolymerTagDartElementImpl] declared in the given [LibraryElement] with
+   * the [elementName]. Maybe `null`.
+   */
+  PolymerTagDartElementImpl _findTagDartElement_inLibrary(LibraryElement library) {
+    try {
+      library.accept(new RecursiveElementVisitor_PolymerHtmlUnitBuilder_findTagDartElement_inLibrary(this));
+    } on PolymerHtmlUnitBuilder_FoundTagDartElementError catch (e) {
+      return e._result;
+    }
+    return null;
+  }
+
+  /**
+   * Returns the only [LibraryElement] referenced by a direct `script` child. Maybe
+   * `null` if none.
+   */
+  LibraryElement get dartUnitElement {
+    // TODO(scheglov) Maybe check if more than one "script".
+    for (ht.XmlTagNode child in _elementNode.tagNodes) {
+      if (child is ht.HtmlScriptTagNode) {
+        HtmlScriptElement scriptElement = child.scriptElement;
+        if (scriptElement is ExternalHtmlScriptElement) {
+          Source scriptSource = scriptElement.scriptSource;
+          if (scriptSource != null) {
+            return _context.getLibraryElement(scriptSource);
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  bool _isPublishedAnnotation(ElementAnnotation annotation) {
+    Element element = annotation.element;
+    if (element != null && element.name == "published") {
+      return true;
+    }
+    return false;
+  }
+
+  bool _isPublishedField(FieldElement field) {
+    List<ElementAnnotation> annotations = field.metadata;
+    for (ElementAnnotation annotation in annotations) {
+      if (_isPublishedAnnotation(annotation)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Reports an error on the attribute's value, or (if absent) on the attribute's name.
+   */
+  void _reportErrorForAttribute(ht.XmlAttributeNode node, ErrorCode errorCode, List<Object> arguments) {
+    _reportErrorForOffset(node.offset, node.length, errorCode, arguments);
+  }
+
+  /**
+   * Reports an error on the attribute's value, or (if absent) on the attribute's name.
+   */
+  void _reportErrorForAttributeValue(ht.XmlAttributeNode node, ErrorCode errorCode, List<Object> arguments) {
+    ht.Token valueToken = node.valueToken;
+    if (valueToken == null || valueToken.isSynthetic) {
+      _reportErrorForAttribute(node, errorCode, arguments);
+    } else {
+      _reportErrorForToken(valueToken, errorCode, arguments);
+    }
+  }
+
+  void _reportErrorForNameToken(PolymerHtmlUnitBuilder_NameToken token, ErrorCode errorCode, List<Object> arguments) {
+    int offset = token._offset;
+    int length = token._value.length;
+    _reportErrorForOffset(offset, length, errorCode, arguments);
+  }
+
+  void _reportErrorForOffset(int offset, int length, ErrorCode errorCode, List<Object> arguments) {
+    _errorListener.onError(new AnalysisError.con2(_source, offset, length, errorCode, arguments));
+  }
+
+  void _reportErrorForToken(ht.Token token, ErrorCode errorCode, List<Object> arguments) {
+    int offset = token.offset;
+    int length = token.length;
+    _reportErrorForOffset(offset, length, errorCode, arguments);
+  }
+}
+
+class PolymerHtmlUnitBuilder_FoundTagDartElementError extends Error {
+  final PolymerTagDartElementImpl _result;
+
+  PolymerHtmlUnitBuilder_FoundTagDartElementError(this._result);
+}
+
+class PolymerHtmlUnitBuilder_NameToken {
+  final int _offset;
+
+  final String _value;
+
+  PolymerHtmlUnitBuilder_NameToken(this._offset, this._value);
+}
+
+class RecursiveElementVisitor_PolymerHtmlUnitBuilder_findTagDartElement_inLibrary extends RecursiveElementVisitor<Object> {
+  final PolymerHtmlUnitBuilder PolymerHtmlUnitBuilder_this;
+
+  RecursiveElementVisitor_PolymerHtmlUnitBuilder_findTagDartElement_inLibrary(this.PolymerHtmlUnitBuilder_this) : super();
+
+  @override
+  Object visitPolymerTagDartElement(PolymerTagDartElement element) {
+    if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
+      throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(element as PolymerTagDartElementImpl);
+    }
+    return null;
+  }
+}
+
+/**
+ * Instances of the class [PolymerHtmlUnitResolver] resolve Polymer specific
+ * [XmlTagNode]s and expressions.
+ *
+ * TODO(scheglov) implement it
+ */
+class PolymerHtmlUnitResolver extends ht.RecursiveXmlVisitor<Object> {
+  final InternalAnalysisContext _context;
+
+  TypeProvider _typeProvider;
+
+  final AnalysisErrorListener _errorListener;
+
+  final Source _source;
+
+  final LineInfo _lineInfo;
+
+  final ht.HtmlUnit _unit;
+
+  PolymerHtmlUnitResolver(this._context, this._errorListener, this._source, this._lineInfo, this._unit) {
+    this._typeProvider = _context.typeProvider;
+  }
+
+  /**
+   * Resolves Polymer specific features.
+   */
+  void resolveUnit() {
+  }
+
+  @override
+  Object visitXmlAttributeNode(ht.XmlAttributeNode node) => super.visitXmlAttributeNode(node);
+
+  @override
+  Object visitXmlTagNode(ht.XmlTagNode node) => super.visitXmlTagNode(node);
+}
+
+/**
  * The abstract class `AnalysisTask` defines the behavior of objects used to perform an
  * analysis task.
  */
 abstract class AnalysisTask {
   /**
    * The context in which the task is to be performed.
    */
   final InternalAnalysisContext context;
 
   /**
@@ skipping 77 matching lines @@
   }
 }
 
 /**
  * The interface `AnalysisTaskVisitor` defines the behavior of objects that can visit tasks.
  * While tasks are not structured in any interesting way, this class provides the ability to
  * dispatch to an appropriate method.
  */
 abstract class AnalysisTaskVisitor<E> {
   /**
+   * Visit a [BuildDartElementModelTask].
+   *
+   * @param task the task to be visited
+   * @return the result of visiting the task
+   * @throws AnalysisException if the visitor throws an exception for some reason
+   */
+  E visitBuildDartElementModelTask(BuildDartElementModelTask task);
+
+  /**
    * Visit a [GenerateDartErrorsTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitGenerateDartErrorsTask(GenerateDartErrorsTask task);
 
   /**
    * Visit a [GenerateDartHintsTask].
@@ skipping 34 matching lines @@
   /**
    * Visit a [ParseHtmlTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitParseHtmlTask(ParseHtmlTask task);
 
   /**
+   * Visit a [PolymerBuildHtmlTask].
+   *
+   * @param task the task to be visited
+   * @return the result of visiting the task
+   * @throws AnalysisException if the visitor throws an exception for some reason
+   */
+  E visitPolymerBuildHtmlTask(PolymerBuildHtmlTask task);
+
+  /**
+   * Visit a [PolymerResolveHtmlTask].
+   *
+   * @param task the task to be visited
+   * @return the result of visiting the task
+   * @throws AnalysisException if the visitor throws an exception for some reason
+   */
+  E visitPolymerResolveHtmlTask(PolymerResolveHtmlTask task);
+
+  /**
    * Visit a [ResolveAngularComponentTemplateTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task);
 
   /**
    * Visit a [ResolveAngularEntryHtmlTask].
@@ skipping 44 matching lines @@
    * Visit a [ScanDartTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitScanDartTask(ScanDartTask task);
 }
 
 /**
+ * Instances of the class `BuildDartElementModelTask` build the element models for all of the
+ * libraries in a cycle.
+ */
+class BuildDartElementModelTask extends AnalysisTask {
+  /**
+   * The library for which an element model was originally requested.
+   */
+  Source _targetLibrary;
+
+  /**
+   * The libraries that are part of the cycle to be resolved.
+   */
+  final List<ResolvableLibrary> librariesInCycle;
+
+  /**
+   * The listener to which analysis errors will be reported.
+   */
+  RecordingErrorListener _errorListener;
+
+  /**
+   * A source object representing the core library (dart:core).
+   */
+  Source _coreLibrarySource;
+
+  /**
+   * The object representing the core library.
+   */
+  ResolvableLibrary _coreLibrary;
+
+  /**
+   * A table mapping library sources to the information being maintained for those libraries.
+   */
+  Map<Source, ResolvableLibrary> _libraryMap = new Map<Source, ResolvableLibrary>();
+
+  /**
+   * Initialize a newly created task to perform analysis within the given context.
+   *
+   * @param context the context in which the task is to be performed
+   * @param targetLibrary the library for which an element model was originally requested
+   * @param librariesInCycle the libraries that are part of the cycle to be resolved
+   */
+  BuildDartElementModelTask(InternalAnalysisContext context, Source targetLibrary, this.librariesInCycle) : super(context) {
+    this._errorListener = new RecordingErrorListener();
+    _coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
+  }
+
+  @override
+  accept(AnalysisTaskVisitor visitor) => visitor.visitBuildDartElementModelTask(this);
+
+  /**
+   * Return the listener to which analysis errors were (or will be) reported.
+   *
+   * @return the listener to which analysis errors were reported
+   */
+  RecordingErrorListener get errorListener => _errorListener;
+
+  /**
+   * Return the library for which an element model was originally requested.
+   *
+   * @return the library for which an element model was originally requested
+   */
+  Source get targetLibrary => _targetLibrary;
+
+  @override
+  String get taskDescription {
+    Source librarySource = librariesInCycle[0].librarySource;
+    if (librarySource == null) {
+      return "build an element model for unknown library";
+    }
+    return "build an element model for ${librarySource.fullName}";
+  }
+
+  @override
+  void internalPerform() {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.LibraryResolver.resolveLibrary");
+    try {
+      //
+      // Build the map of libraries that are known.
+      //
+      _libraryMap = _buildLibraryMap();
+      _coreLibrary = _libraryMap[_coreLibrarySource];
+      LibraryElement coreElement = _coreLibrary.libraryElement;
+      if (coreElement == null) {
+        throw new AnalysisException.con1("Could not resolve dart:core");
+      }
+      instrumentation.metric3("buildLibraryMap", "complete");
+      //
+      // Build the element models representing the libraries being resolved. This is done in three
+      // steps.
+      //
+      // 1. Build the basic element models without making any connections between elements other than
+      //    the basic parent/child relationships. This includes building the elements representing the
+      //    libraries.
+      //
+      _buildElementModels();
+      instrumentation.metric3("buildElementModels", "complete");
+      //
+      // 2. Build the elements for the import and export directives. This requires that we have the
+      //    elements built for the referenced libraries, but because of the possibility of circular
+      //    references needs to happen after all of the library elements have been created.
+      //
+      _buildDirectiveModels();
+      instrumentation.metric3("buildDirectiveModels", "complete");
+      //
+      // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This
+      //    requires that we be able to compute the names visible in the libraries being resolved,
+      //    which in turn requires that we have resolved the import directives.
+      //
+      _buildTypeHierarchies(new TypeProviderImpl(coreElement));
+      instrumentation.metric3("buildTypeHierarchies", "complete");
+    } finally {
+      instrumentation.log();
+    }
+  }
+
+  /**
+   * Build the element model representing the combinators declared by the given directive.
+   *
+   * @param directive the directive that declares the combinators
+   * @return an array containing the import combinators that were built
+   */
+  List<NamespaceCombinator> _buildCombinators(NamespaceDirective directive) {
+    List<NamespaceCombinator> combinators = new List<NamespaceCombinator>();
+    for (Combinator combinator in directive.combinators) {
+      if (combinator is HideCombinator) {
+        HideElementCombinatorImpl hide = new HideElementCombinatorImpl();
+        hide.hiddenNames = _getIdentifiers(combinator.hiddenNames);
+        combinators.add(hide);
+      } else {
+        ShowElementCombinatorImpl show = new ShowElementCombinatorImpl();
+        show.offset = combinator.offset;
+        show.end = combinator.end;
+        show.shownNames = _getIdentifiers((combinator as ShowCombinator).shownNames);
+        combinators.add(show);
+      }
+    }
+    return new List.from(combinators);
+  }
+
+  /**
+   * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
+   * the import and export directives.
+   *
+   * @throws AnalysisException if the defining compilation unit for any of the libraries could not
+   *           be accessed
+   */
+  void _buildDirectiveModels() {
+    AnalysisContext analysisContext = context;
+    for (ResolvableLibrary library in librariesInCycle) {
+      Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
+      List<ImportElement> imports = new List<ImportElement>();
+      List<ExportElement> exports = new List<ExportElement>();
+      for (Directive directive in library.definingCompilationUnit.directives) {
+        if (directive is ImportDirective) {
+          ImportDirective importDirective = directive;
+          String uriContent = importDirective.uriContent;
+          if (DartUriResolver.isDartExtUri(uriContent)) {
+            library.libraryElement.hasExtUri = true;
+          }
+          Source importedSource = importDirective.source;
+          if (importedSource != null && analysisContext.exists(importedSource)) {
+            // The imported source will be null if the URI in the import directive was invalid.
+            ResolvableLibrary importedLibrary = _libraryMap[importedSource];
+            if (importedLibrary != null) {
+              ImportElementImpl importElement = new ImportElementImpl(directive.offset);
+              StringLiteral uriLiteral = importDirective.uri;
+              if (uriLiteral != null) {
+                importElement.uriOffset = uriLiteral.offset;
+                importElement.uriEnd = uriLiteral.end;
+              }
+              importElement.uri = uriContent;
+              importElement.combinators = _buildCombinators(importDirective);
+              LibraryElement importedLibraryElement = importedLibrary.libraryElement;
+              if (importedLibraryElement != null) {
+                importElement.importedLibrary = importedLibraryElement;
+              }
+              SimpleIdentifier prefixNode = directive.prefix;
+              if (prefixNode != null) {
+                importElement.prefixOffset = prefixNode.offset;
+                String prefixName = prefixNode.name;
+                PrefixElementImpl prefix = nameToPrefixMap[prefixName];
+                if (prefix == null) {
+                  prefix = new PrefixElementImpl(prefixNode);
+                  nameToPrefixMap[prefixName] = prefix;
+                }
+                importElement.prefix = prefix;
+                prefixNode.staticElement = prefix;
+              }
+              directive.element = importElement;
+              imports.add(importElement);
+              if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) {
+                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
+              }
+            }
+          }
+        } else if (directive is ExportDirective) {
+          ExportDirective exportDirective = directive;
+          Source exportedSource = exportDirective.source;
+          if (exportedSource != null && analysisContext.exists(exportedSource)) {
+            // The exported source will be null if the URI in the export directive was invalid.
+            ResolvableLibrary exportedLibrary = _libraryMap[exportedSource];
+            if (exportedLibrary != null) {
+              ExportElementImpl exportElement = new ExportElementImpl();
+              StringLiteral uriLiteral = exportDirective.uri;
+              if (uriLiteral != null) {
+                exportElement.uriOffset = uriLiteral.offset;
+                exportElement.uriEnd = uriLiteral.end;
+              }
+              exportElement.uri = exportDirective.uriContent;
+              exportElement.combinators = _buildCombinators(exportDirective);
+              LibraryElement exportedLibraryElement = exportedLibrary.libraryElement;
+              if (exportedLibraryElement != null) {
+                exportElement.exportedLibrary = exportedLibraryElement;
+              }
+              directive.element = exportElement;
+              exports.add(exportElement);
+              if (analysisContext.computeKindOf(exportedSource) != SourceKind.LIBRARY) {
+                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
+              }
+            }
+          }
+        }
+      }
+      Source librarySource = library.librarySource;
+      if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource) {
+        ImportElementImpl importElement = new ImportElementImpl(-1);
+        importElement.importedLibrary = _coreLibrary.libraryElement;
+        importElement.synthetic = true;
+        imports.add(importElement);
+      }
+      LibraryElementImpl libraryElement = library.libraryElement;
+      libraryElement.imports = new List.from(imports);
+      libraryElement.exports = new List.from(exports);
+      if (libraryElement.entryPoint == null) {
+        Namespace namespace = new NamespaceBuilder().createExportNamespaceForLibrary(libraryElement);
+        Element element = namespace.get(LibraryElementBuilder.ENTRY_POINT_NAME);
+        if (element is FunctionElement) {
+          libraryElement.entryPoint = element;
+        }
+      }
+    }
+  }
+
+  /**
+   * Build element models for all of the libraries in the current cycle.
+   *
+   * @throws AnalysisException if any of the element models cannot be built
+   */
+  void _buildElementModels() {
+    for (ResolvableLibrary library in librariesInCycle) {
+      LibraryElementBuilder builder = new LibraryElementBuilder(context, _errorListener);
+      LibraryElementImpl libraryElement = builder.buildLibrary2(library);
+      library.libraryElement = libraryElement;
+    }
+  }
+
+  /**
+   * Build a table mapping library sources to the resolvable libraries representing those libraries.
+   *
+   * @return the map that was built
+   */
+  Map<Source, ResolvableLibrary> _buildLibraryMap() {
+    Map<Source, ResolvableLibrary> libraryMap = new Map<Source, ResolvableLibrary>();
+    int libraryCount = librariesInCycle.length;
+    for (int i = 0; i < libraryCount; i++) {
+      ResolvableLibrary library = librariesInCycle[i];
+      library.errorListener = _errorListener;
+      libraryMap[library.librarySource] = library;
+      List<ResolvableLibrary> dependencies = library.importsAndExports;
+      int dependencyCount = dependencies.length;
+      for (int j = 0; j < dependencyCount; j++) {
+        ResolvableLibrary dependency = dependencies[j];
+        //dependency.setErrorListener(errorListener);
+        libraryMap[dependency.librarySource] = dependency;
+      }
+    }
+    return libraryMap;
+  }
+
+  /**
+   * Resolve the type hierarchy across all of the types declared in the libraries in the current
+   * cycle.
+   *
+   * @throws AnalysisException if any of the type hierarchies could not be resolved
+   */
+  void _buildTypeHierarchies(TypeProvider typeProvider) {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
+    try {
+      for (ResolvableLibrary library in librariesInCycle) {
+        for (ResolvableCompilationUnit unit in library.resolvableCompilationUnits) {
+          Source source = unit.source;
+          CompilationUnit ast = unit.compilationUnit;
+          TypeResolverVisitor visitor = new TypeResolverVisitor.con4(library, source, typeProvider);
+          ast.accept(visitor);
+        }
+      }
+    } finally {
+      timeCounter.stop();
+    }
+  }
+
+  /**
+   * Return an array containing the lexical identifiers associated with the nodes in the given list.
+   *
+   * @param names the AST nodes representing the identifiers
+   * @return the lexical identifiers associated with the nodes in the list
+   */
+  List<String> _getIdentifiers(NodeList<SimpleIdentifier> names) {
+    int count = names.length;
+    List<String> identifiers = new List<String>(count);
+    for (int i = 0; i < count; i++) {
+      identifiers[i] = names[i].name;
+    }
+    return identifiers;
+  }
+}
+
+/**
  * Instances of the class `GenerateDartErrorsTask` generate errors and warnings for a single
  * Dart source.
  */
 class GenerateDartErrorsTask extends AnalysisTask {
   /**
    * The source for which errors and warnings are to be produced.
    */
   final Source source;
 
   /**
@@ skipping 746 matching lines @@
           libraries.add(librarySource);
         }
       } on URISyntaxException catch (e) {
       }
     }
     return super.visitHtmlScriptTagNode(node);
   }
 }
 
 /**
+ * Instances of the class `PolymerBuildHtmlTask` build Polymer specific elements.
+ */
+class PolymerBuildHtmlTask extends AnalysisTask {
+  /**
+   * The source to build which Polymer HTML elements for.
+   */
+  final Source source;
+
+  /**
+   * The time at which the contents of the source were last modified.
+   */
+  final int modificationTime;
+
+  /**
+   * The line information associated with the source.
+   */
+  final LineInfo _lineInfo;
+
+  /**
+   * The HTML unit to be resolved.
+   */
+  final ht.HtmlUnit _unit;
+
+  /**
+   * The resolution errors that were discovered while building elements.
+   */
+  List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
+
+  /**
+   * Initialize a newly created task to perform analysis within the given context.
+   *
+   * @param context the context in which the task is to be performed
+   * @param source the source to be resolved
+   * @param modificationTime the time at which the contents of the source were last modified
+   * @param lineInfo the line information associated with the source
+   * @param unit the HTML unit to build Polymer elements for
+   */
+  PolymerBuildHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._lineInfo, this._unit) : super(context);
+
+  @override
+  accept(AnalysisTaskVisitor visitor) => visitor.visitPolymerBuildHtmlTask(this);
+
+  List<AnalysisError> get errors => _errors;
+
+  @override
+  String get taskDescription => "build Polymer elements ${source.fullName}";
+
+  @override
+  void internalPerform() {
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    PolymerHtmlUnitBuilder resolver = new PolymerHtmlUnitBuilder(context, errorListener, source, _lineInfo, _unit);
+    resolver.build();
+    _errors = errorListener.getErrorsForSource(source);
+  }
+}
+
+/**
+ * Instances of the class `PolymerResolveHtmlTask` performs Polymer specific HTML file
+ * resolution.
+ *
+ * TODO(scheglov) implement it
+ */
+class PolymerResolveHtmlTask extends AnalysisTask {
+  /**
+   * The source to be resolved.
+   */
+  final Source source;
+
+  /**
+   * The time at which the contents of the source were last modified.
+   */
+  final int modificationTime;
+
+  /**
+   * The line information associated with the source.
+   */
+  final LineInfo _lineInfo;
+
+  /**
+   * The HTML unit to be resolved.
+   */
+  final ht.HtmlUnit _unit;
+
+  /**
+   * The resolution errors that were discovered while resolving the source.
+   */
+  List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
+
+  /**
+   * Initialize a newly created task to perform analysis within the given context.
+   *
+   * @param context the context in which the task is to be performed
+   * @param source the source to be resolved
+   * @param modificationTime the time at which the contents of the source were last modified
+   * @param unit the HTML unit to be resolved
+   */
+  PolymerResolveHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._lineInfo, this._unit) : super(context);
+
+  @override
+  accept(AnalysisTaskVisitor visitor) => visitor.visitPolymerResolveHtmlTask(this);
+
+  List<AnalysisError> get errors => _errors;
+
+  @override
+  String get taskDescription => "resolve as Polymer ${source.fullName}";
+
+  @override
+  void internalPerform() {
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    PolymerHtmlUnitResolver resolver = new PolymerHtmlUnitResolver(context, errorListener, source, _lineInfo, _unit);
+    resolver.resolveUnit();
+    _errors = errorListener.getErrorsForSource(source);
+  }
+}
+
+/**
  * Instances of the class `ResolveAngularComponentTemplateTask` resolve HTML template
  * referenced by [AngularComponentElement].
  */
 class ResolveAngularComponentTemplateTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
   final Source source;
 
   /**
@@ skipping 44 matching lines @@
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
    */
   ht.HtmlUnit get resolvedUnit => _resolvedUnit;
 
   @override
-  String get taskDescription => "resolving Angular template ${source}";
+  String get taskDescription => "resolve as Angular template ${source}";
 
   @override
   void internalPerform() {
     //
     // Prepare for resolution.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     LineInfo lineInfo = context.getLineInfo(source);
     //
     // Perform resolution.
@@ skipping 644 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }