New analyzer snapshot.

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 1667 matching lines @@
    * 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 AST structure resulting from building the element model.
+   */
+  static final DataDescriptor<CompilationUnit> BUILT_UNIT = new DataDescriptor<CompilationUnit>("DartEntry.BUILT_UNIT");
+
+  /**
    * 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 354 matching lines @@
     }
     return new List.from(errors);
   }
 
   @override
   CompilationUnit get anyParsedCompilationUnit {
     if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
     }
+    DartEntryImpl_ResolutionState state = _resolutionState;
+    while (state != null) {
+      if (state._builtUnitState == CacheState.VALID) {
+        return state._builtUnit;
+      }
+      state = state._nextState;
+    }
+    ;
     return anyResolvedCompilationUnit;
   }
 
   @override
   CompilationUnit get anyResolvedCompilationUnit {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (state._resolvedUnitState == CacheState.VALID) {
         return state._resolvedUnit;
       }
@@ skipping 40 matching lines @@
         return _parsedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       CompilationUnit unit = _parsedUnit;
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnitAccessed = false;
       _parsedUnit = null;
       return unit;
     }
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
+      if (state._builtUnitState == CacheState.VALID) {
+        // TODO(brianwilkerson) We're cloning the structure to remove any previous resolution data,
+        // but I'm not sure that's necessary.
+        return state._builtUnit.accept(new AstCloner()) as CompilationUnit;
+      }
       if (state._resolvedUnitState == CacheState.VALID) {
         return state._resolvedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
   @override
@@ skipping 27 matching lines @@
     }
   }
 
   @override
   CacheState getStateInLibrary(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS)) {
           return state._buildElementErrorsState;
+        } else if (identical(descriptor, DartEntry.BUILT_UNIT)) {
+          return state._builtUnitState;
         } 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}");
@@ skipping 44 matching lines @@
     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.BUILD_ELEMENT_ERRORS)) {
           return state._buildElementErrors;
+        } else if (identical(descriptor, DartEntry.BUILT_UNIT)) {
+          return state._builtUnit;
         } 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}");
@@ skipping 37 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.BUILD_ELEMENT_ERRORS) || 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.BUILT_UNIT) || 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.BUILD_ELEMENT_ERRORS)) {
           return state._buildElementErrorsState == CacheState.INVALID;
+        } else if (identical(descriptor, DartEntry.BUILT_UNIT)) {
+          return state._builtUnitState == 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;
     } else {
       return super.getState(descriptor) == CacheState.INVALID;
     }
   }
 
   @override
   bool get hasResolvableCompilationUnit {
     if (_parsedUnitState == CacheState.VALID) {
       return true;
     }
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
-      if (state._resolvedUnitState == CacheState.VALID) {
+      if (state._builtUnitState == CacheState.VALID || state._resolvedUnitState == CacheState.VALID) {
         return true;
       }
       state = state._nextState;
     }
     ;
     return false;
   }
 
   @override
   void invalidateAllInformation() {
@@ skipping 18 matching lines @@
     _discardCachedResolutionInformation();
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     if (_parsedUnitState == CacheState.FLUSHED) {
       DartEntryImpl_ResolutionState state = _resolutionState;
       while (state != null) {
-        if (state._resolvedUnitState == CacheState.VALID) {
+        if (state._builtUnitState == CacheState.VALID) {
+          _parsedUnit = state._builtUnit;
+          _parsedUnitAccessed = true;
+          _parsedUnitState = CacheState.VALID;
+          break;
+        } else if (state._resolvedUnitState == CacheState.VALID) {
           _parsedUnit = state._resolvedUnit;
           _parsedUnitAccessed = true;
           _parsedUnitState = CacheState.VALID;
           break;
         }
         state = state._nextState;
       }
     }
     _discardCachedResolutionInformation();
   }
 
   @override
   bool get isRefactoringSafe {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       CacheState resolvedState = state._resolvedUnitState;
       if (resolvedState != CacheState.VALID && resolvedState != CacheState.FLUSHED) {
         return false;
       }
       state = state._nextState;
     }
     return true;
   }
 
+  /**
+   * Record that an error occurred while attempting to build the element model for the source
+   * 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 recordBuildElementError() {
+    _element = null;
+    _elementState = CacheState.ERROR;
+    clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
+    _clientServerState = CacheState.ERROR;
+    _launchableState = CacheState.ERROR;
+    recordResolutionError();
+  }
+
+  /**
+   * Record that an in-process model build has stopped without recording results because the results
+   * were invalidated before they could be recorded.
+   */
+  void recordBuildElementNotInProcess() {
+    if (_elementState == CacheState.IN_PROCESS) {
+      _elementState = CacheState.INVALID;
+    }
+    if (_clientServerState == CacheState.IN_PROCESS) {
+      _clientServerState = CacheState.INVALID;
+    }
+    if (_launchableState == CacheState.IN_PROCESS) {
+      _launchableState = CacheState.INVALID;
+    }
+  }
+
   @override
   void recordContentError() {
     super.recordContentError();
     recordScanError();
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
@@ skipping 62 matching lines @@
     }
     if (_importedLibrariesState == CacheState.IN_PROCESS) {
       _importedLibrariesState = CacheState.INVALID;
     }
     if (_includedPartsState == CacheState.IN_PROCESS) {
       _includedPartsState = CacheState.INVALID;
     }
   }
 
   /**
-   * 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.
+   * Record that an error occurred while attempting to resolve the source 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() {
     _element = null;
     _elementState = CacheState.ERROR;
     clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
     _clientServerState = CacheState.ERROR;
     _launchableState = CacheState.ERROR;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.ERROR;
     _resolutionState.recordResolutionError();
   }
 
   /**
-   * Record that an in-process parse has stopped without recording results because the results were
-   * invalidated before they could be recorded.
+   * Record that an in-process resolution has stopped without recording results because the results
+   * were invalidated before they could be recorded.
    */
   void recordResolutionNotInProcess() {
     if (_elementState == CacheState.IN_PROCESS) {
       _elementState = CacheState.INVALID;
     }
     if (_clientServerState == CacheState.IN_PROCESS) {
       _clientServerState = CacheState.INVALID;
     }
     if (_launchableState == CacheState.IN_PROCESS) {
       _launchableState = CacheState.INVALID;
     }
+    // TODO(brianwilkerson) Remove the code above this line after resolution and element building
+    // are separated.
     if (_publicNamespaceState == CacheState.IN_PROCESS) {
       _publicNamespaceState = CacheState.INVALID;
     }
     _resolutionState.recordResolutionNotInProcess();
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
@@ skipping 144 matching lines @@
    * @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.BUILD_ELEMENT_ERRORS)) {
       state._buildElementErrors = updatedValue(cacheState, state._buildElementErrors, AnalysisError.NO_ERRORS);
       state._buildElementErrorsState = cacheState;
+    } else if (identical(descriptor, DartEntry.BUILT_UNIT)) {
+      state._builtUnit = updatedValue(cacheState, state._builtUnit, null);
+      state._builtUnitState = 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)) {
@@ skipping 57 matching lines @@
    * @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.BUILD_ELEMENT_ERRORS)) {
       state._buildElementErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._buildElementErrorsState = CacheState.VALID;
+    } else if (identical(descriptor, DartEntry.BUILT_UNIT)) {
+      state._builtUnit = value as CompilationUnit;
+      state._builtUnitState = 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)) {
@@ skipping 140 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 compilation unit that contains references to the built element model.
+   */
+  CacheState _builtUnitState = CacheState.INVALID;
+
+  /**
+   * The compilation unit that contains references to the built element model, or `null` if
+   * that compilation unit is not currently cached.
+   */
+  CompilationUnit _builtUnit;
+
+  /**
    * 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;
 
@@ skipping 42 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;
+    _builtUnitState = other._builtUnitState;
+    _builtUnit = other._builtUnit;
     _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 (_builtUnitState == CacheState.VALID) {
+      _builtUnitState = CacheState.FLUSHED;
+      _builtUnit = null;
+    }
     if (_resolvedUnitState == CacheState.VALID) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
     }
     if (_nextState != null) {
       _nextState.flushAstStructures();
     }
   }
 
-  bool get hasErrorState => _buildElementErrorsState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _verificationErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || (_nextState != null && _nextState.hasErrorState);
+  bool get hasErrorState => _builtUnitState == CacheState.ERROR || _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;
+    _builtUnitState = CacheState.INVALID;
+    _builtUnit = 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() {
+    _builtUnitState = CacheState.ERROR;
+    _builtUnit = null;
     _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("; builtUnit = ");
+      builder.append(_builtUnitState);
       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);
@@ skipping 1984 matching lines @@
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLVED_UNIT);
       }
     }
     return statistics;
   }
 
   @override
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
-    return new TypeProviderImpl(computeLibraryElement(coreSource));
+    if (coreSource == null) {
+      throw new AnalysisException.con1("Could not create a source for dart:core");
+    }
+    LibraryElement coreElement = computeLibraryElement(coreSource);
+    if (coreElement == null) {
+      throw new AnalysisException.con1("Could not create an element for dart:core");
+    }
+    return new TypeProviderImpl(coreElement);
   }
 
   @override
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
@@ skipping 282 matching lines @@
         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);
             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(dartCopy, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
               dartCopy.recordResolutionError();
               _cache.remove(source);
@@ skipping 540 matching lines @@
       // change, this loop will eventually terminate.
       //
       htmlEntry = _cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT);
       htmlEntry = new ResolveHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.PARSED_UNIT)).perform(_resultRecorder) as HtmlEntry;
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
   /**
+   * Compute the transitive closure of all libraries that depend on the given library by adding such
+   * libraries to the given collection.
+   *
+   * @param library the library on which the other libraries depend
+   * @param librariesToInvalidate the libraries that depend on the given library
+   */
+  void _computeAllLibrariesDependingOn(Source library, Set<Source> librariesToInvalidate) {
+    if (librariesToInvalidate.add(library)) {
+      for (Source dependentLibrary in getLibrariesDependingOn(library)) {
+        _computeAllLibrariesDependingOn(dependentLibrary, librariesToInvalidate);
+      }
+    }
+  }
+
+  /**
    * Given the encoded form of a source, use the source factory to reconstitute the original source.
    *
    * @param encoding the encoded form of a source
    * @return the source represented by the encoding
    */
   Source _computeSourceFromEncoding(String encoding) => _sourceFactory.fromEncoding(encoding);
 
   /**
    * Return `true` if the given array of sources contains the given source.
    *
@@ skipping 20 matching lines @@
   bool _containsAny(List<Source> sources, List<Source> targetSources) {
     for (Source targetSource in targetSources) {
       if (_contains(sources, targetSource)) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Create a [BuildDartElementModelTask] for the given source, marking the built unit as
+   * being in-process.
+   *
+   * @param source the source for the library whose element model is to be built
+   * @param dartEntry the entry for the source
+   * @return task data representing the created task
+   */
+  AnalysisContextImpl_TaskData _createBuildDartElementModelTask(Source source, DartEntry dartEntry) {
+    try {
+      AnalysisContextImpl_CycleBuilder builder = new AnalysisContextImpl_CycleBuilder(this);
+      builder.computeCycleContaining(source);
+      AnalysisContextImpl_TaskData taskData = builder.taskData;
+      if (taskData != null) {
+        return taskData;
+      }
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      dartCopy.setStateInLibrary(DartEntry.BUILT_UNIT, source, CacheState.IN_PROCESS);
+      _cache.put(source, dartCopy);
+      return new AnalysisContextImpl_TaskData(new BuildDartElementModelTask(this, source, builder.librariesInCycle), false);
+    } on AnalysisException catch (exception) {
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      dartCopy.recordBuildElementError();
+      dartCopy.exception = exception;
+      _cache.put(source, dartCopy);
+      AnalysisEngine.instance.logger.logError2("Internal error trying to compute the next analysis task", exception);
+    }
+    return new AnalysisContextImpl_TaskData(null, false);
+  }
+
+  /**
    * Create an analysis cache based on the given source factory.
    *
    * @param factory the source factory containing the information needed to create the cache
    * @return the cache that was created
    */
   AnalysisCache _createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
       return new AnalysisCache(<CachePartition> [_privatePartition]);
     }
     DartSdk sdk = factory.dartSdk;
@@ skipping 195 matching lines @@
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
     htmlCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
     _cache.put(source, htmlCopy);
     return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
-   * Create a [ResolveDartLibraryTask] for the given source, marking the element model as
-   * being in-process.
+   * Create a [ResolveDartLibraryTask] for the given source, marking ? as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source, DartEntry dartEntry) {
     try {
       AnalysisContextImpl_CycleBuilder builder = new AnalysisContextImpl_CycleBuilder(this);
       builder.computeCycleContaining(source);
       AnalysisContextImpl_TaskData taskData = builder.taskData;
       if (taskData != null) {
         return taskData;
       }
       return new AnalysisContextImpl_TaskData(new ResolveDartLibraryCycleTask(this, source, source, builder.librariesInCycle), false);
     } on AnalysisException catch (exception) {
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      dartCopy.recordResolutionError();
+      dartCopy.exception = exception;
+      _cache.put(source, dartCopy);
       AnalysisEngine.instance.logger.logError2("Internal error trying to compute the next analysis task", exception);
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Create a [ResolveHtmlTask] for the given source, marking the resolved unit as being
    * in-process.
    *
    * @param source the source whose content is to be resolved
@@ skipping 1061 matching lines @@
       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);
+            dartCopy.setValueInLibrary(DartEntry.BUILT_UNIT, librarySource, unit);
             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();
+            dartCopy.recordBuildElementError();
             _cache.remove(source);
           }
           dartCopy.exception = thrownException;
           _cache.put(source, dartCopy);
           if (source != librarySource) {
             _workManager.add(librarySource, SourcePriority.PRIORITY_PART);
           }
           if (source == targetLibrary) {
             targetEntry = dartCopy;
           }
@@ skipping 10 matching lines @@
           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();
+              dartCopy.recordBuildElementNotInProcess();
             } 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();
+              dartCopy.recordBuildElementError();
               _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");
           }
@@ skipping 1138 matching lines @@
       htmlCopy.modificationTime = getModificationStamp(source);
       _invalidateAngularResolution(htmlCopy);
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
-        librariesToInvalidate.add(containingLibrary);
-        for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
-          librariesToInvalidate.add(dependentLibrary);
-        }
+        _computeAllLibrariesDependingOn(containingLibrary, librariesToInvalidate);
       }
       for (Source library in librariesToInvalidate) {
         //    for (Source library : containingLibraries) {
         _invalidateLibraryResolution(library);
       }
       _removeFromParts(source, _cache.get(source) as DartEntry);
       DartEntryImpl dartCopy = (_cache.get(source) as DartEntry).writableCopy;
       dartCopy.modificationTime = getModificationStamp(source);
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
@@ skipping 2473 matching lines @@
       _index = 0;
       _queueIndex++;
       while (_queueIndex < WorkManager_this._workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }
 
 /**
- * An [Expression] with optional [AngularFilterNode]s.
+ * An [Expression] with optional [AngularFormatterNode]s.
  */
 class AngularExpression {
   /**
-   * The [Expression] to apply filters to.
+   * The [Expression] to apply formatters to.
    */
   final Expression expression;
 
   /**
-   * The filters to apply.
+   * The formatters to apply.
    */
-  final List<AngularFilterNode> filters;
+  final List<AngularFormatterNode> formatters;
 
-  AngularExpression(this.expression, this.filters);
+  AngularExpression(this.expression, this.formatters);
 
   /**
    * Return the offset of the character immediately following the last character of this node's
    * source range. This is equivalent to `node.getOffset() + node.getLength()`.
    *
    * @return the offset of the character just past the node's source range
    */
   int get end {
-    if (filters.isEmpty) {
+    if (formatters.isEmpty) {
       return expression.end;
     }
-    AngularFilterNode lastFilter = filters[filters.length - 1];
-    List<AngularFilterArgument> filterArguments = lastFilter.arguments;
-    if (filterArguments.isEmpty) {
-      return lastFilter.name.end;
+    AngularFormatterNode lastFormatter = formatters[formatters.length - 1];
+    List<AngularFormatterArgument> formatterArguments = lastFormatter.arguments;
+    if (formatterArguments.isEmpty) {
+      return lastFormatter.name.end;
     }
-    return filterArguments[filterArguments.length - 1].expression.end;
+    return formatterArguments[formatterArguments.length - 1].expression.end;
   }
 
   /**
    * Return Dart [Expression]s this Angular expression consists of.
    */
   List<Expression> get expressions {
     List<Expression> expressions = [];
     expressions.add(expression);
-    for (AngularFilterNode filter in filters) {
-      expressions.add(filter.name);
-      for (AngularFilterArgument filterArgument in filter.arguments) {
-        expressions.addAll(filterArgument.subExpressions);
-        expressions.add(filterArgument.expression);
+    for (AngularFormatterNode formatter in formatters) {
+      expressions.add(formatter.name);
+      for (AngularFormatterArgument formatterArgument in formatter.arguments) {
+        expressions.addAll(formatterArgument.subExpressions);
+        expressions.add(formatterArgument.expression);
       }
     }
     return expressions;
   }
 
   /**
    * Return the number of characters in the expression's source range.
    */
   int get length => end - offset;
 
   /**
    * Return the offset of the first character in the expression's source range.
    */
   int get offset => expression.offset;
 }
 
 /**
- * Angular filter argument.
+ * Angular formatter argument.
  */
-class AngularFilterArgument {
+class AngularFormatterArgument {
   /**
    * The [TokenType#COLON] token.
    */
   final Token token;
 
   /**
    * The argument expression.
    */
   final Expression expression;
 
   /**
    * The optional sub-[Expression]s.
    */
   List<Expression> subExpressions = Expression.EMPTY_ARRAY;
 
-  AngularFilterArgument(this.token, this.expression);
+  AngularFormatterArgument(this.token, this.expression);
 }
 
 /**
- * Angular filter node.
+ * Angular formatter node.
  */
-class AngularFilterNode {
+class AngularFormatterNode {
   /**
    * The [TokenType#BAR] token.
    */
   final Token token;
 
   /**
-   * The name of the filter.
+   * The name of the formatter.
    */
   final SimpleIdentifier name;
 
   /**
-   * The arguments for this filter.
+   * The arguments for this formatter.
    */
-  final List<AngularFilterArgument> arguments;
+  final List<AngularFormatterArgument> arguments;
 
-  AngularFilterNode(this.token, this.name, this.arguments);
+  AngularFormatterNode(this.token, this.name, this.arguments);
 }
 
 /**
  * Instances of the class [AngularHtmlUnitResolver] resolve Angular specific expressions.
  */
 class AngularHtmlUnitResolver extends ht.RecursiveXmlVisitor<Object> {
   static String _NG_APP = "ng-app";
 
   /**
    * Checks if given [Element] is an artificial local variable and returns corresponding
@@ skipping 333 matching lines @@
    * Parses given [String] as an [AngularExpression] at the given offset.
    */
   AngularExpression _parseAngularExpression(String contents, int startIndex, int endIndex, int offset) {
     Token token = _scanDart(contents, startIndex, endIndex, offset);
     return _parseAngularExpressionInToken(token);
   }
 
   AngularExpression _parseAngularExpressionInToken(Token token) {
     List<Token> tokens = _splitAtBar(token);
     Expression mainExpression = _parseDartExpressionInToken(tokens[0]);
-    // parse filters
-    List<AngularFilterNode> filters = [];
+    // parse formatters
+    List<AngularFormatterNode> formatters = [];
     for (int i = 1; i < tokens.length; i++) {
-      Token filterToken = tokens[i];
-      Token barToken = filterToken;
-      filterToken = filterToken.next;
+      Token formatterToken = tokens[i];
+      Token barToken = formatterToken;
+      formatterToken = formatterToken.next;
       // parse name
-      Expression nameExpression = _parseDartExpressionInToken(filterToken);
+      Expression nameExpression = _parseDartExpressionInToken(formatterToken);
       if (nameExpression is! SimpleIdentifier) {
-        _reportErrorForNode(AngularCode.INVALID_FILTER_NAME, nameExpression, []);
+        _reportErrorForNode(AngularCode.INVALID_FORMATTER_NAME, nameExpression, []);
         continue;
       }
       SimpleIdentifier name = nameExpression as SimpleIdentifier;
-      filterToken = name.endToken.next;
+      formatterToken = name.endToken.next;
       // parse arguments
-      List<AngularFilterArgument> arguments = [];
-      while (filterToken.type != TokenType.EOF) {
+      List<AngularFormatterArgument> arguments = [];
+      while (formatterToken.type != TokenType.EOF) {
         // skip ":"
-        Token colonToken = filterToken;
+        Token colonToken = formatterToken;
         if (colonToken.type == TokenType.COLON) {
-          filterToken = filterToken.next;
+          formatterToken = formatterToken.next;
         } else {
-          _reportErrorForToken(AngularCode.MISSING_FILTER_COLON, colonToken, []);
+          _reportErrorForToken(AngularCode.MISSING_FORMATTER_COLON, colonToken, []);
         }
         // parse argument
-        Expression argument = _parseDartExpressionInToken(filterToken);
-        arguments.add(new AngularFilterArgument(colonToken, argument));
+        Expression argument = _parseDartExpressionInToken(formatterToken);
+        arguments.add(new AngularFormatterArgument(colonToken, argument));
         // next token
-        filterToken = argument.endToken.next;
+        formatterToken = argument.endToken.next;
       }
-      filters.add(new AngularFilterNode(barToken, name, arguments));
+      formatters.add(new AngularFormatterNode(barToken, name, arguments));
     }
     // done
-    return new AngularExpression(mainExpression, filters);
+    return new AngularExpression(mainExpression, formatters);
   }
 
   /**
    * Parses given [String] as an [Expression] at the given offset.
    */
   Expression _parseDartExpression(String contents, int startIndex, int endIndex, int offset) {
     Token token = _scanDart(contents, startIndex, endIndex, offset);
     return _parseDartExpressionInToken(token);
   }
 
@@ skipping 55 matching lines @@
     // create CompilationUnitElementImpl
     String unitName = _source.shortName;
     _unitElement = new CompilationUnitElementImpl(unitName);
     _unitElement.source = _source;
     // create LibraryElementImpl
     _libraryElement = new LibraryElementImpl(_context, null);
     _libraryElement.definingCompilationUnit = _unitElement;
     _libraryElement.angularHtml = true;
     _injectedLibraries.add(_libraryElement);
     // create FunctionElementImpl
-    _functionElement = new FunctionElementImpl.con2(0);
+    _functionElement = new FunctionElementImpl.forOffset(0);
     _unitElement.functions = <FunctionElement> [_functionElement];
   }
 
   /**
    * Creates new [NgProcessor] for the given [AngularElement], maybe `null` if not
    * supported.
    */
   NgProcessor _createProcessor(AngularElement element) {
     if (element is AngularComponentElement) {
       AngularComponentElement component = element;
       return new NgComponentElementProcessor(component);
     }
     if (element is AngularControllerElement) {
       AngularControllerElement controller = element;
       return new NgControllerElementProcessor(controller);
     }
-    if (element is AngularDirectiveElement) {
-      AngularDirectiveElement directive = element;
-      return new NgDirectiveElementProcessor(directive);
+    if (element is AngularDecoratorElement) {
+      AngularDecoratorElement directive = element;
+      return new NgDecoratorElementProcessor(directive);
     }
     return null;
   }
 
   /**
    * Puts into [resolver] an [ResolverVisitor] to resolve [Expression]s in
    * [source].
    */
   void _createResolver() {
     InheritanceManager inheritanceManager = new InheritanceManager(_libraryElement);
@@ skipping 140 matching lines @@
         _defineTopVariable_forScopeProperty(scopeProperty);
       }
     }
     // add processors
     for (AngularElement angularElement in angularElements) {
       NgProcessor processor = _createProcessor(angularElement);
       if (processor != null) {
         _processors.add(processor);
       }
     }
-    // define filters
+    // define formatters
     for (AngularElement angularElement in angularElements) {
-      if (angularElement is AngularFilterElement) {
+      if (angularElement is AngularFormatterElement) {
         _defineTopVariable_forClassElement(angularElement);
       }
     }
     // run this HTML visitor
     _unit.accept(this);
     // simulate imports for injects
     {
       List<ImportElement> imports = [];
       for (LibraryElement injectedLibrary in _injectedLibraries) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
@@ skipping 143 matching lines @@
 
   AngularXmlExpression(this.expression);
 
   @override
   ht.XmlExpression_Reference getReference(int offset) {
     // main expression
     ht.XmlExpression_Reference reference = _getReferenceAtNode(expression.expression, offset);
     if (reference != null) {
       return reference;
     }
-    // filters
-    for (AngularFilterNode filter in expression.filters) {
-      // filter name
-      reference = _getReferenceAtNode(filter.name, offset);
+    // formatters
+    for (AngularFormatterNode formatter in expression.formatters) {
+      // formatter name
+      reference = _getReferenceAtNode(formatter.name, offset);
       if (reference != null) {
         return reference;
       }
-      // filter arguments
-      for (AngularFilterArgument filterArgument in filter.arguments) {
-        reference = _getReferenceAtNode(filterArgument.expression, offset);
+      // formatter arguments
+      for (AngularFormatterArgument formatterArgument in formatter.arguments) {
+        reference = _getReferenceAtNode(formatterArgument.expression, offset);
         if (reference != null) {
           return reference;
         }
       }
     }
     return null;
   }
 
   /**
    * If the given [AstNode] has an [Element] at the given offset, then returns
@@ skipping 98 matching lines @@
     LocalVariableElementImpl variable = resolver._createLocalVariableWithName(type, name);
     resolver._defineVariable(variable);
     variable.toolkitObjects = <AngularElement> [_element];
   }
 
   @override
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 }
 
 /**
- * [NgDirectiveElementProcessor] applies [AngularDirectiveElement] by parsing mapped
+ * [NgDecoratorElementProcessor] applies [AngularDecoratorElement] by parsing mapped
  * attributes as expressions.
  */
-class NgDirectiveElementProcessor extends NgDirectiveProcessor {
-  final AngularDirectiveElement _element;
+class NgDecoratorElementProcessor extends NgDirectiveProcessor {
+  final AngularDecoratorElement _element;
 
-  NgDirectiveElementProcessor(this._element);
+  NgDecoratorElementProcessor(this._element);
 
   @override
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     String selectorAttributeName = null;
     {
       AngularSelectorElement selector = _element.selector;
       if (selector is HasAttributeSelectorElementImpl) {
         selectorAttributeName = selector.name;
         // resolve attribute expression
         ht.XmlAttributeNode attribute = node.getAttribute(selectorAttributeName);
@@ skipping 45 matching lines @@
    */
   void _onNgEventDirective(AngularHtmlUnitResolver resolver) {
     if (_element.isClass("NgEventDirective")) {
       DartType dynamicType = resolver.typeProvider.dynamicType;
       resolver._defineVariable(resolver._createLocalVariableWithName(dynamicType, "\$event"));
     }
   }
 }
 
 /**
- * [NgDirectiveProcessor] describes any <code>NgDirective</code> annotation instance.
+ * [NgDirectiveProcessor] describes any <code>Directive</code> annotation instance.
  */
 abstract class NgDirectiveProcessor extends NgProcessor {
   static bool hasValue(ht.XmlAttributeNode attribute) {
     ht.Token valueToken = attribute.valueToken;
     return valueToken != null && !valueToken.isSynthetic;
   }
 
   static AngularRawXmlExpression newAngularRawXmlExpression(AngularExpression e) => new AngularRawXmlExpression(e);
 
   static ht.RawXmlExpression newRawXmlExpression(Expression e) => new ht.RawXmlExpression(e);
@@ skipping 739 matching lines @@
 }
 
 /**
  * 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;
+  final 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;
@@ skipping 13 matching lines @@
    */
   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) {
+  BuildDartElementModelTask(InternalAnalysisContext context, this.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");
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.BuildDartElementModel.internalPerform");
     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");
       }
@@ skipping 15 matching lines @@
       //
       _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");
+      instrumentation.metric2("librariesInCycles", librariesInCycle.length);
+      for (ResolvableLibrary lib in librariesInCycle) {
+        instrumentation.metric2("librariesInCycles-CompilationUnitSources-Size", lib.compilationUnitSources.length);
+      }
     } 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
@@ skipping 1793 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }