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 221 matching lines @@
    * @return all of the errors associated with the given source
    * @throws AnalysisException if the errors could not be determined because the analysis could not
    *           be performed
    * @see #getErrors(Source)
    */
   List<AnalysisError> computeErrors(Source source);
 
   /**
    * Return the element model corresponding to the HTML file defined by the given source. If the
    * element model does not yet exist it will be created. The process of creating an element model
-   * for an HTML file can long-running, depending on the size of the file and the number of
+   * for an HTML file can be long-running, depending on the size of the file and the number of
    * libraries that are defined in it (via script tags) that also need to have a model built for
    * them.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source defining the HTML file whose element model is to be returned
    * @return the element model corresponding to the HTML file defined by the given source
    * @throws AnalysisException if the element model could not be determined because the analysis
    *           could not be performed
    * @see #getHtmlElement(Source)
@@ skipping 74 matching lines @@
   /**
    * Return the set of analysis options controlling the behavior of this context. Clients should not
    * modify the returned set of options. The options should only be set by invoking the method
    * [setAnalysisOptions].
    *
    * @return the set of analysis options controlling the behavior of this context
    */
   AnalysisOptions get analysisOptions;
 
   /**
+   * Return the Angular application that contains the HTML file defined by the given source, or
+   * `null` if the source does not represent an HTML file, the Angular application containing
+   * the file has not yet been resolved, or the analysis of the HTML file failed for some reason.
+   *
+   * @param htmlSource the source defining the HTML file
+   * @return the Angular application that contains the HTML file defined by the given source
+   */
+  AngularApplication getAngularApplicationWithHtml(Source htmlSource);
+
+  /**
    * Return the element model corresponding to the compilation unit defined by the given source in
    * the library defined by the given source, or `null` if the element model does not
    * currently exist or if the library cannot be analyzed for some reason.
    *
    * @param unitSource the source of the compilation unit
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          compilation unit
    * @return the element model corresponding to the compilation unit defined by the given source
    */
   CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource);
@@ skipping 112 matching lines @@
    * Return the sources for the defining compilation units of any libraries that depend on the given
    * library. One library depends on another if it either imports or exports that library.
    *
    * @param librarySource the source for the defining compilation unit of the library being depended
    *          on
    * @return the sources for the libraries that depend on the given library
    */
   List<Source> getLibrariesDependingOn(Source librarySource);
 
   /**
+   * Return the sources for the defining compilation units of any libraries that are referenced from
+   * the given HTML file.
+   *
+   * @param htmlSource the source for the HTML file
+   * @return the sources for the libraries that are referenced by the given HTML file
+   */
+  List<Source> getLibrariesReferencedFromHtml(Source htmlSource);
+
+  /**
    * Return the element model corresponding to the library defined by the given source, or
    * `null` if the element model does not currently exist or if the library cannot be analyzed
    * for some reason.
    *
    * @param source the source defining the library whose element model is to be returned
    * @return the element model corresponding to the library defined by the given source
    */
   LibraryElement getLibraryElement(Source source);
 
   /**
@@ skipping 154 matching lines @@
    * information about the consequent changes to the analysis results. This method can be long
    * running.
    *
    * @return the results of performing the analysis
    */
   AnalysisResult performAnalysisTask();
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param unitSource the source to be parsed and resolved
    * @param library the library containing the source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
    * @see #getResolvedCompilationUnit(Source, LibraryElement)
    */
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library);
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    * Return the resolved AST structure, or `null` if the source could not be either parsed or
    * resolved.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param unitSource the source to be parsed and resolved
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
    * @see #getResolvedCompilationUnit(Source, Source)
    */
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource);
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param htmlSource the source to be parsed and resolved
    * @return the result of resolving the AST structure representing the content of the source
    * @throws AnalysisException if the analysis could not be performed
    */
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource);
 
   /**
    * Set the set of analysis options controlling the behavior of this context to the given options.
    * Clients can safely assume that all necessary analysis results have been invalidated.
    *
@@ skipping 591 matching lines @@
       _sourceMap[removedSource] = dartCopy;
     }
     return true;
   }
 
   /**
    * Remove and return one source from the list of recently used sources whose AST structure can be
    * flushed from the cache. The source that will be returned will be the source that has been
    * unreferenced for the longest period of time but that is not a priority for analysis.
    *
+   * It is possible for there to be no AST that can be flushed, in which case `null` will be
+   * returned. This happens, for example, if the context is reserving the AST's needed to resolve a
+   * cycle of libraries and the number of AST's being reserved is larger than the current cache
+   * size.
+   *
    * @return the source that was removed
    */
   Source _removeAstToFlush() {
     int sourceToRemove = -1;
     for (int i = 0; i < _recentlyUsed.length; i++) {
       Source source = _recentlyUsed[i];
       RetentionPriority priority = _retentionPolicy.getAstPriority(source, _sourceMap[source]);
       if (identical(priority, RetentionPriority.LOW)) {
         return _recentlyUsed.removeAt(i);
       } else if (identical(priority, RetentionPriority.MEDIUM) && sourceToRemove < 0) {
         sourceToRemove = i;
       }
     }
     if (sourceToRemove < 0) {
-      AnalysisEngine.instance.logger.logError2("Internal error: Could not flush data from the cache", new JavaException());
       return null;
     }
     return _recentlyUsed.removeAt(sourceToRemove);
   }
 }
 
 /**
  * Instances of the class `CacheRetentionPolicy` define the behavior of objects that determine
  * how important it is for data to be retained in the analysis cache.
  */
@@ skipping 1656 matching lines @@
    */
   void flushAstStructures() {
     if (identical(_parsedUnitState, CacheState.VALID)) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnit = null;
     }
     if (identical(_resolvedUnitState, CacheState.VALID)) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
     }
+    if (identical(_angularEntryState, CacheState.VALID)) {
+      _angularEntryState = CacheState.FLUSHED;
+    }
+    if (identical(_angularErrorsState, CacheState.VALID)) {
+      _angularErrorsState = CacheState.FLUSHED;
+    }
   }
 
   @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     if (_parseErrors != null) {
       for (AnalysisError error in _parseErrors) {
         errors.add(error);
       }
     }
@@ skipping 715 matching lines @@
 class AnalysisContextImpl implements InternalAnalysisContext {
   /**
    * The difference between the maximum cache size and the maximum priority order size. The priority
    * list must be capped so that it is less than the cache size. Failure to do so can result in an
    * infinite loop in performAnalysisTask() because re-caching one AST structure can cause another
    * priority source's AST structure to be flushed.
    */
   static int _PRIORITY_ORDER_SIZE_DELTA = 4;
 
   /**
+   * A flag indicating whether trace output should be produced as analysis tasks are performed. Used
+   * for debugging.
+   */
+  static bool _TRACE_PERFORM_TASK = false;
+
+  /**
    * The set of analysis options controlling the behavior of this context.
    */
   AnalysisOptionsImpl _options = new AnalysisOptionsImpl();
 
   /**
+   * A flag indicating whether errors related to sources in the SDK should be generated and
+   * reported.
+   */
+  bool _generateSdkErrors = true;
+
+  /**
    * A flag indicating whether this context is disposed.
    */
   bool _disposed = false;
 
   /**
    * A cache of content used to override the default content of a source.
    */
   ContentCache _contentCache = new ContentCache();
 
   /**
    * The source factory used to create the sources that can be analyzed in this context.
    */
   SourceFactory _sourceFactory;
 
   /**
+   * A source representing the core library.
+   */
+  Source _coreLibrarySource;
+
+  /**
    * A table mapping the sources known to the context to the information known about the source.
    */
   AnalysisCache _cache;
 
   /**
    * An array containing sources for which data should not be flushed.
    */
   List<Source> _priorityOrder = Source.EMPTY_ARRAY;
 
   /**
+   * An array containing sources whose AST structure is needed in order to resolve the next library
+   * to be resolved.
+   */
+  Set<Source> _neededForResolution = null;
+
+  /**
    * A table mapping sources to the change notices that are waiting to be returned related to that
    * source.
    */
   Map<Source, ChangeNoticeImpl> _pendingNotices = new Map<Source, ChangeNoticeImpl>();
 
   /**
    * A set containing information about the tasks that have been performed since the last change
    * notification. Used to detect infinite loops in [performAnalysisTask].
    */
   Set<String> _recentTasks = new Set<String>();
@@ skipping 70 matching lines @@
       _sourceChanged(source);
     }
     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");
+      //        logInformation("Added Dart sources, invalidating all resolution information");
       for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
         Source source = mapEntry.getKey();
         SourceEntry sourceEntry = mapEntry.getValue();
         if (!source.isInSystemLibrary && sourceEntry is DartEntry) {
           DartEntry dartEntry = sourceEntry;
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           _removeFromParts(source, dartEntry);
           dartCopy.invalidateAllResolutionInformation();
           mapEntry.setValue(dartCopy);
           SourcePriority priority = SourcePriority.UNKNOWN;
@@ skipping 183 matching lines @@
         newContext.addSourceInfo(source, entry.getValue().writableCopy);
       }
     }
     return newContext;
   }
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
+  AngularApplication getAngularApplicationWithHtml(Source htmlSource) {
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
+    if (sourceEntry is HtmlEntry) {
+      HtmlEntry htmlEntry = sourceEntry;
+      AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
+      if (application != null) {
+        return application;
+      }
+      return htmlEntry.getValue(HtmlEntry.ANGULAR_ENTRY);
+    }
+    return null;
+  }
+
+  @override
   CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource) {
     LibraryElement libraryElement = getLibraryElement(librarySource);
     if (libraryElement != null) {
       // try defining unit
       CompilationUnitElement definingUnit = libraryElement.definingCompilationUnit;
       if (definingUnit.source == unitSource) {
         return definingUnit;
       }
       // try parts
       for (CompilationUnitElement partUnit in libraryElement.parts) {
@@ skipping 153 matching lines @@
         }
       }
     }
     if (dependentLibraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(dependentLibraries);
   }
 
   @override
+  List<Source> getLibrariesReferencedFromHtml(Source htmlSource) {
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
+    if (sourceEntry is HtmlEntry) {
+      HtmlEntry htmlEntry = sourceEntry;
+      return htmlEntry.getValue(HtmlEntry.REFERENCED_LIBRARIES);
+    }
+    return Source.EMPTY_ARRAY;
+  }
+
+  @override
   LibraryElement getLibraryElement(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.ELEMENT);
     }
     return null;
   }
 
   @override
   List<Source> get librarySources => _getSources(SourceKind.LIBRARY);
@@ skipping 110 matching lines @@
     // 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);
     }
     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;
         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 (identical(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.HINTS);
           statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
           statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
-          statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
+          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;
         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;
   }
 
   @override
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     return new TypeProviderImpl(computeLibraryElement(coreSource));
   }
 
   @override
-  TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) {
-    DartEntry dartEntry = _getReadableDartEntry(unitSource);
-    if (dartEntry == null) {
-      throw new AnalysisException.con1("internalResolveCompilationUnit invoked for non-Dart file: ${unitSource.fullName}");
-    }
-    Source librarySource = libraryElement.source;
-    dartEntry = _cacheDartResolutionData(unitSource, librarySource, dartEntry, DartEntry.RESOLVED_UNIT);
-    return new TimestampedData<CompilationUnit>(dartEntry.modificationTime, dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource));
-  }
-
-  @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;
   }
 
   @override
@@ skipping 30 matching lines @@
   }
 
   @override
   CompilationUnit parseCompilationUnit(Source source) => _getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
   @override
   ht.HtmlUnit parseHtmlUnit(Source source) => _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
   @override
   AnalysisResult performAnalysisTask() {
+    if (_TRACE_PERFORM_TASK) {
+      print("----------------------------------------");
+    }
     int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextAnalysisTask;
     int getEnd = JavaSystem.currentTimeMillis();
     if (task == null && _validateCacheConsistency()) {
       task = nextAnalysisTask;
     }
     if (task == null) {
       return new AnalysisResult(_getChangeNotices(true), getEnd - getStart, null, -1);
     }
     String taskDescriptor = task.toString();
-    if (_recentTasks.add(taskDescriptor)) {
-      _logInformation("Performing task: ${taskDescriptor}");
-    } else {
-      _logInformation("*** Performing repeated task: ${taskDescriptor}");
+    //    if (recentTasks.add(taskDescriptor)) {
+    //      logInformation("Performing task: " + taskDescriptor);
+    //    } else {
+    //      if (TRACE_PERFORM_TASK) {
+    //        System.out.print("* ");
+    //      }
+    //      logInformation("*** Performing repeated task: " + taskDescriptor);
+    //    }
+    if (_TRACE_PERFORM_TASK) {
+      print(taskDescriptor);
     }
     int performStart = JavaSystem.currentTimeMillis();
     try {
       task.perform(_resultRecorder);
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not perform analysis task: ${taskDescriptor}", exception);
     } on AnalysisException catch (exception) {
       if (exception.cause is! JavaIOException) {
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
@@ skipping 32 matching lines @@
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => _getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
   @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   @override
   void set analysisOptions(AnalysisOptions options) {
-    bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint) || this._options.preserveComments != options.preserveComments;
+    bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || this._options.generateSdkErrors != options.generateSdkErrors || this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint) || this._options.preserveComments != options.preserveComments;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
       _cache.maxCacheSize = cacheSize;
       //
       // Cap the size of the priority list to being less than the cache size. Failure to do so can
       // result in an infinite loop in performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
       if (_priorityOrder.length > maxPriorityOrderSize) {
         List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize);
         JavaSystem.arraycopy(_priorityOrder, 0, newPriorityOrder, 0, maxPriorityOrderSize);
         _priorityOrder = newPriorityOrder;
       }
     }
     this._options.analyzeFunctionBodies = options.analyzeFunctionBodies;
+    this._options.generateSdkErrors = options.generateSdkErrors;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.preserveComments = options.preserveComments;
+    _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
       _invalidateAllResolutionInformation();
     }
   }
 
   @override
   void set analysisPriorityOrder(List<Source> sources) {
     if (sources == null || sources.isEmpty) {
       _priorityOrder = Source.EMPTY_ARRAY;
     } else {
@@ skipping 66 matching lines @@
     if (identical(_sourceFactory, factory)) {
       return;
     } else if (factory.context != null) {
       throw new IllegalStateException("Source factories cannot be shared between contexts");
     }
     if (_sourceFactory != null) {
       _sourceFactory.context = null;
     }
     factory.context = this;
     _sourceFactory = factory;
+    _coreLibrarySource = _sourceFactory.forUri(DartSdk.DART_CORE);
     _invalidateAllResolutionInformation();
   }
 
   /**
-   * Record the results produced by performing a [ResolveDartLibraryTask]. 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 [ResolveDartLibraryCycleTask]. 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 recordResolveDartLibraryCycleTaskResults(ResolveDartLibraryCycleTask task) {
+    LibraryResolver2 resolver = task.libraryResolver;
+    AnalysisException thrownException = task.exception;
+    DartEntry unitEntry = null;
+    Source unitSource = task.unitSource;
+    if (resolver != null) {
+      //
+      // The resolver should only be null if an exception was thrown before (or while) it was
+      // being created.
+      //
+      List<ResolvableLibrary> resolvedLibraries = resolver.resolvedLibraries;
+      if (resolvedLibraries == null) {
+        //
+        // The resolved libraries should only be null if an exception was thrown during resolution.
+        //
+        unitEntry = _getReadableDartEntry(unitSource);
+        if (unitEntry == null) {
+          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+        }
+        DartEntryImpl dartCopy = unitEntry.writableCopy;
+        dartCopy.recordResolutionError();
+        dartCopy.exception = thrownException;
+        _cache.put(unitSource, dartCopy);
+        _cache.remove(unitSource);
+        if (thrownException != null) {
+          throw thrownException;
+        }
+        return dartCopy;
+      }
+      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;
+            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);
+              }
+              _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);
+            }
+            if (source == unitSource) {
+              unitEntry = dartCopy;
+            }
+            if (_generateSdkErrors || !source.isInSystemLibrary) {
+              ChangeNoticeImpl notice = _getNotice(source);
+              notice.compilationUnit = unit;
+              notice.setErrors(dartCopy.allErrors, lineInfo);
+            }
+          }
+        }
+      } else {
+        PrintStringWriter writer = new PrintStringWriter();
+        writer.println("Library resolution results discarded for");
+        for (ResolvableLibrary library in resolvedLibraries) {
+          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 == unitSource) {
+                unitEntry = dartCopy;
+              }
+            } else {
+              writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
+            }
+          }
+        }
+        _logInformation(writer.toString());
+      }
+    }
+    if (thrownException != null) {
+      throw thrownException;
+    }
+    if (unitEntry == null) {
+      unitEntry = _getReadableDartEntry(unitSource);
+      if (unitEntry == null) {
+        throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+      }
+    }
+    return unitEntry;
+  }
+
   DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) {
     LibraryResolver resolver = task.libraryResolver;
     AnalysisException thrownException = task.exception;
     DartEntry unitEntry = null;
     Source unitSource = task.unitSource;
     if (resolver != null) {
       //
       // The resolver should only be null if an exception was thrown before (or while) it was
       // being created.
       //
       Set<Library> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown during resolution.
         //
         unitEntry = _getReadableDartEntry(unitSource);
         if (unitEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
         DartEntryImpl dartCopy = unitEntry.writableCopy;
         dartCopy.recordResolutionError();
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw thrownException;
         }
         return dartCopy;
       }
-      if (_allModificationTimesMatch(resolvedLibraries)) {
+      if (_allModificationTimesMatch2(resolvedLibraries)) {
         Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
         RecordingErrorListener errorListener = resolver.errorListener;
         for (Library 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);
@@ skipping 20 matching lines @@
               _cache.remove(source);
             }
             dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
               unitEntry = dartCopy;
             }
-            ChangeNoticeImpl notice = _getNotice(source);
-            notice.compilationUnit = unit;
-            notice.setErrors(dartCopy.allErrors, lineInfo);
+            if (_generateSdkErrors || !source.isInSystemLibrary) {
+              ChangeNoticeImpl notice = _getNotice(source);
+              notice.compilationUnit = unit;
+              notice.setErrors(dartCopy.allErrors, lineInfo);
+            }
           }
         }
       } else {
         PrintStringWriter writer = new PrintStringWriter();
         writer.println("Library resolution results discarded for");
         for (Library library in resolvedLibraries) {
           for (Source source in library.compilationUnitSources) {
             DartEntry dartEntry = _getReadableDartEntry(source);
             if (dartEntry != null) {
               int resultTime = library.getModificationTime(source);
@@ skipping 68 matching lines @@
 
   /**
    * 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.
    *
    * @param resolver the library resolver used to resolve one or more libraries
    * @return `true` if we should record the results of the resolution
    * @throws AnalysisException if any of the modification times could not be determined (this should
    *           not happen)
    */
-  bool _allModificationTimesMatch(Set<Library> resolvedLibraries) {
+  bool _allModificationTimesMatch(List<ResolvableLibrary> resolvedLibraries) {
+    bool allTimesMatch = true;
+    for (ResolvableLibrary library in resolvedLibraries) {
+      for (Source source in library.compilationUnitSources) {
+        DartEntry dartEntry = _getReadableDartEntry(source);
+        if (dartEntry == null) {
+          // 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 resolve non-Dart file as a Dart file: ${source.fullName}");
+        }
+        int sourceTime = getModificationStamp(source);
+        int resultTime = library.getModificationTime(source);
+        if (sourceTime != resultTime) {
+          // The source has changed without the context being notified. Simulate notification.
+          _sourceChanged(source);
+          allTimesMatch = false;
+        }
+      }
+    }
+    return allTimesMatch;
+  }
+
+  /**
+   * 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.
+   *
+   * @param resolver the library resolver used to resolve one or more libraries
+   * @return `true` if we should record the results of the resolution
+   * @throws AnalysisException if any of the modification times could not be determined (this should
+   *           not happen)
+   */
+  bool _allModificationTimesMatch2(Set<Library> resolvedLibraries) {
     bool allTimesMatch = true;
     for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         DartEntry dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           // 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 resolve non-Dart file as a Dart file: ${source.fullName}");
         }
         int sourceTime = getModificationStamp(source);
         int resultTime = library.getModificationTime(source);
         if (sourceTime != resultTime) {
           // The source has changed without the context being notified. Simulate notification.
           _sourceChanged(source);
           allTimesMatch = false;
         }
       }
     }
     return allTimesMatch;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by generating hints
    * for the library if the data is not already cached.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   DartEntry _cacheDartHintData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
-      dartEntry = new GenerateDartHintsTask(this, getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
+      DartEntry libraryEntry = _getReadableDartEntry(librarySource);
+      libraryEntry = _cacheDartResolutionData(librarySource, librarySource, libraryEntry, DartEntry.ELEMENT);
+      LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+      CompilationUnitElement definingUnit = libraryElement.definingCompilationUnit;
+      List<CompilationUnitElement> parts = libraryElement.parts;
+      List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(parts.length + 1);
+      units[0] = _getResolvedUnit(definingUnit, librarySource);
+      if (units[0] == null) {
+        Source source = definingUnit.source;
+        units[0] = new TimestampedData<CompilationUnit>(getModificationStamp(source), resolveCompilationUnit(source, libraryElement));
+      }
+      for (int i = 0; i < parts.length; i++) {
+        units[i + 1] = _getResolvedUnit(parts[i], librarySource);
+        if (units[i + 1] == null) {
+          Source source = parts[i].source;
+          units[i + 1] = new TimestampedData<CompilationUnit>(getModificationStamp(source), resolveCompilationUnit(source, libraryElement));
+        }
+      }
+      dartEntry = new GenerateDartHintsTask(this, units, getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState#VALID] or [CacheState#ERROR]. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   DartEntry _cacheDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
@@ skipping 16 matching lines @@
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by resolving the
    * source in the context of the library if it is not already cached.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   DartEntry _cacheDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
@@ skipping 11 matching lines @@
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState#VALID] or [CacheState#ERROR]. This
    * method assumes that the data can be produced by scanning the source if it is not already
    * cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
   DartEntry _cacheDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
@@ skipping 37 matching lines @@
   DartEntry _cacheDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
-      dartEntry = new GenerateDartErrorsTask(this, unitSource, getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
+      LibraryElement library = computeLibraryElement(librarySource);
+      dartEntry = new GenerateDartErrorsTask(this, unitSource, dartEntry.modificationTime, resolveCompilationUnit(unitSource, library), library).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the state of the given descriptors is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   HtmlEntry _cacheHtmlParseData(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
@@ skipping 25 matching lines @@
     }
     return htmlEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which the state of the data
    * represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param dartEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   HtmlEntry _cacheHtmlResolutionData(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     //
@@ skipping 46 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 [GenerateDartErrorsTask] for the given source, marking the verification errors
+   * as being in-process.
+   *
+   * @param source the source whose content is to be verified
+   * @param dartEntry the entry for the source
+   * @param librarySource the source for the library containing the source
+   * @param libraryEntry the entry for the library
+   * @return task data representing the created task
+   */
+  AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source source, DartEntry dartEntry, Source librarySource, SourceEntry libraryEntry) {
+    if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) != CacheState.VALID || libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
+    }
+    CompilationUnit unit = dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+    LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+    DartEntryImpl dartCopy = dartEntry.writableCopy;
+    dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
+    _cache.put(source, dartCopy);
+    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, source, dartCopy.modificationTime, unit, libraryElement), false);
+  }
+
+  /**
+   * Create a [GenerateDartHintsTask] for the given source, marking the hints as being
+   * in-process.
+   *
+   * @param source the source whose content is to be verified
+   * @param dartEntry the entry for the source
+   * @param librarySource the source for the library containing the source
+   * @param libraryEntry the entry for the library
+   * @return task data representing the created task
+   */
+  AnalysisContextImpl_TaskData _createGenerateDartHintsTask(Source source, DartEntry dartEntry, Source librarySource, DartEntry libraryEntry) {
+    if (libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
+      return _createResolveDartLibraryTask(librarySource, libraryEntry);
+    }
+    LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+    CompilationUnitElement definingUnit = libraryElement.definingCompilationUnit;
+    List<CompilationUnitElement> parts = libraryElement.parts;
+    List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(parts.length + 1);
+    units[0] = _getResolvedUnit(definingUnit, librarySource);
+    if (units[0] == null) {
+      // TODO(brianwilkerson) We should return a ResolveDartUnitTask (unless there are multiple ASTs
+      // that need to be resolved.
+      return _createResolveDartLibraryTask(librarySource, libraryEntry);
+    }
+    for (int i = 0; i < parts.length; i++) {
+      units[i + 1] = _getResolvedUnit(parts[i], librarySource);
+      if (units[i + 1] == null) {
+        // TODO(brianwilkerson) We should return a ResolveDartUnitTask (unless there are multiple
+        // ASTs that need to be resolved.
+        return _createResolveDartLibraryTask(librarySource, libraryEntry);
+      }
+    }
+    DartEntryImpl dartCopy = dartEntry.writableCopy;
+    dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
+    _cache.put(source, dartCopy);
+    return new AnalysisContextImpl_TaskData(new GenerateDartHintsTask(this, units, libraryElement), false);
+  }
+
+  /**
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGetContentTask(Source source, SourceEntry sourceEntry) {
     SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
     sourceCopy.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
     _cache.put(source, sourceCopy);
@@ skipping 72 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.
+   *
+   * @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) {
+      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
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
       return _createParseHtmlTask(source, htmlEntry);
@@ skipping 73 matching lines @@
     List<ChangeNotice> notices = new List.from(_pendingNotices.values);
     _pendingNotices.clear();
     return notices;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by generating hints for the library if it is not already cached.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object _getDartHintData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartHintData(unitSource, librarySource, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return dartEntry.getValue(descriptor);
     }
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   Object _getDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartParseData(source, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       _accessedAst(source);
       return dartEntry.anyParsedCompilationUnit;
     }
     return dartEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not a Dart file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   Object _getDartParseData2(Source source, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
       return _getDartParseData(source, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by resolving the source in the context of the library if it is not already cached.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object _getDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return dartEntry.getValue(descriptor);
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       _accessedAst(unitSource);
     }
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source, or the given default value if the
    * source is not a Dart file. This method assumes that the data can be produced by resolving the
    * source in the context of the library if it is not already cached.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object _getDartResolutionData2(Source unitSource, Source librarySource, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = _getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
       return _getDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by scanning the
    * source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
   Object _getDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartScanData(source, dartEntry, descriptor);
     return dartEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not a Dart file. This
    * method assumes that the data can be produced by scanning the source if it is not already
    * cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
   Object _getDartScanData2(Source source, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
@@ skipping 25 matching lines @@
   Object _getDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor);
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   Object _getHtmlParseData(Source source, DataDescriptor descriptor, Object defaultValue) {
     HtmlEntry htmlEntry = _getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       return defaultValue;
     }
     htmlEntry = _cacheHtmlParseData(source, htmlEntry, descriptor);
     if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       _accessedAst(source);
       return htmlEntry.anyParsedUnit;
     }
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by resolving the source if it is not already
    * cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object _getHtmlResolutionData(Source source, DataDescriptor descriptor, Object defaultValue) {
     HtmlEntry htmlEntry = _getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       return defaultValue;
     }
     try {
       return _getHtmlResolutionData2(source, htmlEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the entry representing the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object _getHtmlResolutionData2(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     htmlEntry = _cacheHtmlResolutionData(source, htmlEntry, descriptor);
     if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
       _accessedAst(source);
     }
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * Look through the cache for a task that needs to be performed. Return the task that was found,
    * or `null` if there is no more work to be done.
    *
    * @return the next task that needs to be performed
    */
   AnalysisTask get nextAnalysisTask {
     bool hintsEnabled = _options.hint;
-    bool sdkErrorsEnabled = _options.generateSdkErrors;
     bool hasBlockedTask = false;
     //
     // Look for incremental analysis
     //
     if (_incrementalAnalysisCache != null && _incrementalAnalysisCache.hasWork) {
       AnalysisTask task = new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
       _incrementalAnalysisCache = null;
       return task;
     }
     //
     // Look for a priority source that needs to be analyzed.
     //
-    for (Source source in _priorityOrder) {
-      AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), true, hintsEnabled, sdkErrorsEnabled);
+    int priorityCount = _priorityOrder.length;
+    for (int i = 0; i < priorityCount; i++) {
+      Source source = _priorityOrder[i];
+      AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), true, hintsEnabled);
       AnalysisTask task = taskData.task;
       if (task != null) {
         return task;
       } else if (taskData.isBlocked) {
         hasBlockedTask = true;
       }
     }
+    if (_neededForResolution != null) {
+      for (Source source in _neededForResolution) {
+        SourceEntry sourceEntry = _cache.get(source);
+        if (sourceEntry is DartEntry) {
+          DartEntry dartEntry = sourceEntry;
+          if (!dartEntry.hasResolvableCompilationUnit) {
+            AnalysisContextImpl_TaskData taskData = _createParseDartTask(source, dartEntry);
+            AnalysisTask task = taskData.task;
+            if (task != null) {
+              return task;
+            } else if (taskData.isBlocked) {
+              hasBlockedTask = true;
+            }
+          }
+        }
+      }
+    }
     //
     // Look for a non-priority source that needs to be analyzed.
     //
     List<Source> sourcesToRemove = new List<Source>();
     WorkManager_WorkIterator sources = _workManager.iterator();
     while (sources.hasNext) {
       Source source = sources.next();
-      AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), false, hintsEnabled, sdkErrorsEnabled);
+      AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), false, hintsEnabled);
       AnalysisTask task = taskData.task;
       if (task != null) {
+        int count = sourcesToRemove.length;
+        for (int i = 0; i < count; i++) {
+          _workManager.remove(sourcesToRemove[i]);
+        }
         return task;
       } else if (taskData.isBlocked) {
         hasBlockedTask = true;
       } else {
         sourcesToRemove.add(source);
       }
     }
     int count = sourcesToRemove.length;
     for (int i = 0; i < count; i++) {
       _workManager.remove(sourcesToRemove[i]);
@@ skipping 21 matching lines @@
    * Look at the given source to see whether a task needs to be performed related to it. Return the
    * task that should be performed, or `null` if there is no more work to be done for the
    * source.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be checked
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
-   * @param sdkErrorsEnabled `true` if errors, warnings and hints should be generated for
-   *          sources in the SDK
    * @return the next task that needs to be performed for the given source
    */
-  AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
+  AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled) {
     if (sourceEntry == null) {
       return new AnalysisContextImpl_TaskData(null, false);
     }
     CacheState contentState = sourceEntry.getState(SourceEntry.CONTENT);
     if (identical(contentState, CacheState.INVALID)) {
       return _createGetContentTask(source, sourceEntry);
     } else if (identical(contentState, CacheState.IN_PROCESS)) {
       // We are already in the process of getting the content. There's nothing else we can do with
       // this source until that's complete.
       return new AnalysisContextImpl_TaskData(null, true);
@@ skipping 10 matching lines @@
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         return _createParseDartTask(source, dartEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
           return _createParseDartTask(source, dartEntry);
         }
       }
+      SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
+      if (identical(kind, SourceKind.UNKNOWN)) {
+        return _createParseDartTask(source, dartEntry);
+      } else if (identical(kind, SourceKind.LIBRARY)) {
+        CacheState elementState = dartEntry.getState(DartEntry.ELEMENT);
+        if (identical(elementState, CacheState.INVALID)) {
+          return _createResolveDartLibraryTask(source, dartEntry);
+        }
+      }
       List<Source> librariesContaining = dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
       for (Source librarySource in librariesContaining) {
         SourceEntry libraryEntry = _cache.get(librarySource);
         if (libraryEntry is DartEntry) {
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
+            //return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             DartEntryImpl libraryCopy = libraryEntry.writableCopy;
             libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             _cache.put(librarySource, libraryCopy);
             return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           CacheState resolvedUnitState = dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
           if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
             //
             // The commented out lines below are an optimization that doesn't quite work yet. The
             // problem is that if the source was not resolved because it wasn't part of any library,
             // then there won't be any elements in the element model that we can use to resolve it.
             //
             //LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             //if (libraryElement != null) {
+            //  return new ResolveDartUnitTask(this, source, libraryElement);
+            //}
+            // Possibly replace with: return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
             _cache.put(source, dartCopy);
-            //return new ResolveDartUnitTask(this, source, libraryElement);
             return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
-          if (sdkErrorsEnabled || !source.isInSystemLibrary) {
+          if (_generateSdkErrors || !source.isInSystemLibrary) {
             CacheState verificationErrorsState = dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
             if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
-              LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-              if (libraryElement != null) {
-                DartEntryImpl dartCopy = dartEntry.writableCopy;
-                dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
-                _cache.put(source, dartCopy);
-                return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, source, libraryElement), false);
-              }
+              return _createGenerateDartErrorsTask(source, dartEntry, librarySource, libraryEntry);
             }
             if (hintsEnabled) {
               CacheState hintsState = dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource);
               if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
-                LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-                if (libraryElement != null) {
-                  DartEntryImpl dartCopy = dartEntry.writableCopy;
-                  dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
-                  _cache.put(source, dartCopy);
-                  return new AnalysisContextImpl_TaskData(new GenerateDartHintsTask(this, libraryElement), false);
-                }
+                return _createGenerateDartHintsTask(source, dartEntry, librarySource, libraryEntry);
               }
             }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       CacheState parseErrorsState = htmlEntry.getState(HtmlEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         return _createParseHtmlTask(source, htmlEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         ht.HtmlUnit parsedUnit = htmlEntry.anyParsedUnit;
         if (parsedUnit == null) {
           return _createParseHtmlTask(source, htmlEntry);
         }
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
       if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
         return _createResolveHtmlTask(source, htmlEntry);
       }
       //
       // Angular support
       //
       if (_options.analyzeAngular) {
         // Try to resolve the HTML as an Angular entry point.
         CacheState angularEntryState = htmlEntry.getState(HtmlEntry.ANGULAR_ENTRY);
-        if (identical(angularEntryState, CacheState.INVALID)) {
+        if (identical(angularEntryState, CacheState.INVALID) || (isPriority && identical(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 (identical(angularErrorsState, CacheState.INVALID)) {
+        if (identical(angularErrorsState, CacheState.INVALID) || (isPriority && identical(angularErrorsState, CacheState.FLUSHED))) {
           return _createResolveAngularComponentTemplateTask(source, htmlEntry);
         }
       }
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Return a change notice for the given source, creating one if one does not already exist.
    *
@@ skipping 62 matching lines @@
   /**
    * Return the cache entry associated with the given source, or `null` if there is no entry
    * associated with the source.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   SourceEntry _getReadableSourceEntryOrNull(Source source) => _cache.get(source);
 
   /**
+   * Return a resolved compilation unit corresponding to the given element in the given library, or
+   * `null` if the information is not cached.
+   *
+   * @param element the element representing the compilation unit
+   * @param librarySource the source representing the library containing the unit
+   * @return the specified resolved compilation unit
+   */
+  TimestampedData<CompilationUnit> _getResolvedUnit(CompilationUnitElement element, Source librarySource) {
+    SourceEntry sourceEntry = _cache.get(element.source);
+    if (sourceEntry is DartEntry) {
+      DartEntry dartEntry = sourceEntry;
+      if (identical(dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource), CacheState.VALID)) {
+        return new TimestampedData<CompilationUnit>(dartEntry.modificationTime, dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource));
+      }
+    }
+    return null;
+  }
+
+  /**
    * 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 (identical(entry.getValue().kind, kind)) {
         sources.add(entry.getKey());
@@ skipping 81 matching lines @@
         return;
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
       if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
         sources.add(source);
         return;
       }
       // Angular
       if (_options.analyzeAngular) {
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
-        if (identical(angularErrorsState, CacheState.INVALID)) {
+        if (identical(angularErrorsState, CacheState.INVALID) || (isPriority && identical(angularErrorsState, CacheState.FLUSHED))) {
           AngularApplication entryInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_ENTRY);
           if (entryInfo != null) {
             sources.add(source);
             return;
           }
           AngularApplication applicationInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
           if (applicationInfo != null) {
             AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
             if (component != null) {
               sources.add(source);
@@ skipping 66 matching lines @@
       }
     }
     // reset Dart sources
     List<Source> oldElementSources = application.elementSources;
     for (Source elementSource in oldElementSources) {
       DartEntry dartEntry = _getReadableDartEntry(elementSource);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
       _cache.put(elementSource, dartCopy);
       // notify about (disappeared) Angular errors
-      ChangeNoticeImpl notice = _getNotice(elementSource);
-      notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
+      if (_generateSdkErrors || !elementSource.isInSystemLibrary) {
+        ChangeNoticeImpl notice = _getNotice(elementSource);
+        notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
+      }
     }
   }
 
   /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param librarySource the source of the library being invalidated
    * @param writer the writer to which debugging information should be written
    */
   void _invalidateLibraryResolution(Source librarySource, PrintStringWriter writer) {
     // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these caches if
     // the public namespace hasn't changed, which will be a fairly common case. The question is
     // whether we can afford the time to compute the namespace to look for differences.
     DartEntry libraryEntry = _getReadableDartEntry(librarySource);
     if (libraryEntry != null) {
       List<Source> includedParts = libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
       DartEntryImpl libraryCopy = libraryEntry.writableCopy;
-      int oldTime = libraryCopy.modificationTime;
+      //      long oldTime = libraryCopy.getModificationTime();
       libraryCopy.invalidateAllResolutionInformation();
       _cache.put(librarySource, libraryCopy);
       _workManager.add(librarySource, SourcePriority.LIBRARY);
-      if (writer != null) {
-        writer.println("  Invalidated library source: ${_debuggingString(librarySource)} (previously modified at ${oldTime})");
-      }
+      //      if (writer != null) {
+      //        writer.println("  Invalidated library source: " + debuggingString(librarySource)
+      //            + " (previously modified at " + oldTime + ")");
+      //      }
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
           DartEntryImpl partCopy = partEntry.writableCopy;
-          oldTime = partCopy.modificationTime;
+          //          oldTime = partCopy.getModificationTime();
           if (partEntry != libraryCopy) {
             partCopy.removeContainingLibrary(librarySource);
             _workManager.add(librarySource, SourcePriority.NORMAL_PART);
           }
           partCopy.invalidateAllResolutionInformation();
           _cache.put(partSource, partCopy);
-          if (writer != null) {
-            writer.println("  Invalidated part source: ${_debuggingString(partSource)} (previously modified at ${oldTime})");
-          }
         }
       }
     }
     // invalidate Angular applications
     List<AngularApplication> angularApplicationsCopy = [];
     for (AngularApplication application in angularApplicationsCopy) {
       if (application.dependsOn(librarySource)) {
         Source entryPointSource = application.entryPoint;
         HtmlEntry entry = _getReadableHtmlEntry(entryPointSource);
         HtmlEntryImpl entryCopy = entry.writableCopy;
@@ skipping 87 matching lines @@
         }
       }
       // update Dart sources errors
       List<Source> newElementSources = application.elementSources;
       for (Source elementSource in newElementSources) {
         DartEntry dartEntry = _getReadableDartEntry(elementSource);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.setValue(DartEntry.ANGULAR_ERRORS, task.getErrors(elementSource));
         _cache.put(elementSource, dartCopy);
         // notify about Dart errors
-        ChangeNoticeImpl notice = _getNotice(elementSource);
-        notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
+        if (_generateSdkErrors || !elementSource.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(elementSource);
+          notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
+        }
       }
     }
     // remember Angular entry point
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
    * 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) {
     dartCopy.setValue(DartEntry.ELEMENT, library);
     dartCopy.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
     dartCopy.setValue(DartEntry.IS_CLIENT, _isClient(library, htmlSource, new Set<LibraryElement>()));
-    // TODO(brianwilkerson) Understand why we're doing this both here and in
-    // ResolveDartDependenciesTask and whether we should also be capturing the imported and exported
-    // sources here.
-    _removeFromParts(librarySource, dartEntry);
-    List<CompilationUnitElement> parts = library.parts;
-    int count = parts.length;
-    List<Source> unitSources = new List<Source>(count + 1);
-    unitSources[0] = library.definingCompilationUnit.source;
-    for (int i = 0; i < count; i++) {
-      Source unitSource = parts[i].source;
-      unitSources[i + 1] = unitSource;
-      DartEntry unitEntry = _getReadableDartEntry(unitSource);
-      if (unitSource != null) {
-        DartEntryImpl unitCopy = unitEntry.writableCopy;
-        unitCopy.addContainingLibrary(librarySource);
-        _cache.put(unitSource, unitCopy);
-      }
-    }
-    dartCopy.setValue(DartEntry.INCLUDED_PARTS, unitSources);
   }
 
   /**
    * 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
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
@@ skipping 18 matching lines @@
         // 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;
       if (thrownException == null) {
         dartCopy.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        }
       } else {
         dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
       _logInformation2("Generated errors discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
@@ skipping 78 matching lines @@
           // The source has changed without the context being notified. Simulate notification.
           _sourceChanged(unitSource);
           dartEntry = _getReadableDartEntry(unitSource);
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
           }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
           dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, results.data);
-          ChangeNoticeImpl notice = _getNotice(unitSource);
-          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+          if (_generateSdkErrors || !unitSource.isInSystemLibrary) {
+            ChangeNoticeImpl notice = _getNotice(unitSource);
+            notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+          }
         } else {
           dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
         }
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
         dartEntry = dartCopy;
       } else {
         _logInformation2("Generated hints discarded for ${_debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
         if (identical(dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource), CacheState.IN_PROCESS)) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
@@ skipping 66 matching lines @@
   /**
    * Record the results produced by performing a [IncrementalAnalysisTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry _recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
     CompilationUnit unit = task.compilationUnit;
     if (unit != null) {
-      ChangeNoticeImpl notice = _getNotice(task.source);
-      notice.compilationUnit = unit;
+      if (_generateSdkErrors || !task.source.isInSystemLibrary) {
+        ChangeNoticeImpl notice = _getNotice(task.source);
+        notice.compilationUnit = unit;
+      }
       _incrementalAnalysisCache = IncrementalAnalysisCache.cacheResult(task.cache, unit);
     }
     return null;
   }
 
   /**
    * Record the results produced by performing a [ParseDartTask]. 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 45 matching lines @@
             partCopy.addContainingLibrary(source);
             _cache.put(partSource, partCopy);
           }
         }
         dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
         dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
         dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
         dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
         dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(dartCopy.allErrors, task.lineInfo);
+        }
         // Verify that the incrementally parsed and resolved unit in the incremental cache
         // is structurally equivalent to the fully parsed unit
         _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
       } else {
         _removeFromParts(source, dartEntry);
         dartCopy.recordParseError();
         _cache.removedAst(source);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
@@ skipping 64 matching lines @@
       }
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
       if (thrownException == null) {
         LineInfo lineInfo = task.lineInfo;
         ht.HtmlUnit unit = task.htmlUnit;
         htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
         htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
         htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(htmlCopy.allErrors, lineInfo);
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(htmlCopy.allErrors, lineInfo);
+        }
       } else {
         htmlCopy.recordParseError();
         _cache.removedAst(source);
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       _logInformation2("Parse results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
@@ skipping 63 matching lines @@
         _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));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          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) {
         //
@@ skipping 59 matching lines @@
         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));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          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) {
         //
@@ skipping 140 matching lines @@
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
         htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
         htmlCopy.setValue(HtmlEntry.ELEMENT, task.element);
         htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.htmlUnit = task.resolvedUnit;
-        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.htmlUnit = task.resolvedUnit;
+          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        }
       } else {
         htmlCopy.recordResolutionError();
         _cache.removedAst(source);
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       _logInformation2("Resolution results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
@@ skipping 62 matching lines @@
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         LineInfo lineInfo = task.lineInfo;
         dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         dartCopy.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
         dartCopy.setValue(DartEntry.SCAN_ERRORS, task.errors);
         _cache.storedAst(source);
         _workManager.add(source, SourcePriority.NORMAL_PART);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(dartEntry.allErrors, lineInfo);
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(dartEntry.allErrors, lineInfo);
+        }
       } else {
         _removeFromParts(source, dartEntry);
         dartCopy.recordScanError();
         _cache.removedAst(source);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
       _logInformation2("Scan results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
@@ skipping 77 matching lines @@
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been added
    * @return `true` if the new source is a Dart file
    */
   bool _sourceAvailable(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       sourceEntry = _createSourceEntry(source);
-      _logInformation("Added new source: ${_debuggingString(source)}");
     } else {
       SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
-      int oldTime = sourceCopy.modificationTime;
+      //      long oldTime = sourceCopy.getModificationTime();
       sourceCopy.modificationTime = getModificationStamp(source);
       // TODO(brianwilkerson) Understand why we're not invalidating the cache.
       _cache.put(source, sourceCopy);
-      _logInformation("Added new source: ${_debuggingString(source)} (previously modified at ${oldTime})");
     }
     if (sourceEntry is HtmlEntry) {
       _workManager.add(source, SourcePriority.HTML);
     } else {
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
     return sourceEntry is DartEntry;
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been changed
    */
   void _sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null || sourceEntry.modificationTime == getModificationStamp(source)) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
-      if (sourceEntry == null) {
-        _logInformation("Modified source, but there is no entry: ${_debuggingString(source)}");
-      } else {
-        _logInformation("Modified source, but modification time matches: ${_debuggingString(source)}");
-      }
+      //      if (sourceEntry == null) {
+      //        logInformation("Modified source, but there is no entry: " + debuggingString(source));
+      //      } else {
+      //        logInformation("Modified source, but modification time matches: " + debuggingString(source));
+      //      }
       return;
     }
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
-      int oldTime = htmlCopy.modificationTime;
+      //      long oldTime = htmlCopy.getModificationTime();
       htmlCopy.modificationTime = getModificationStamp(source);
       _invalidateAngularResolution(htmlCopy);
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
-      _logInformation("Modified HTML source: ${_debuggingString(source)} (previously modified at ${oldTime})");
     } 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);
         }
       }
       PrintStringWriter writer = new PrintStringWriter();
-      int oldTime = sourceEntry.modificationTime;
-      writer.println("Modified Dart source: ${_debuggingString(source)} (previously modified at ${oldTime})");
       for (Source library in librariesToInvalidate) {
         //    for (Source library : containingLibraries) {
         _invalidateLibraryResolution(library, writer);
       }
       _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);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.UNKNOWN);
-      _logInformation(writer.toString());
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void _sourceRemoved(Source source) {
     PrintStringWriter writer = new PrintStringWriter();
-    writer.println("Removed source: ${_debuggingString(source)}");
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
       _invalidateAngularResolution(htmlCopy);
     } else if (sourceEntry is DartEntry) {
       Set<Source> libraries = new Set<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         _invalidateLibraryResolution(librarySource, writer);
       }
     }
     _cache.remove(source);
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
-    _logInformation(writer.toString());
   }
 
   /**
    * Check the cache for any invalid entries (entries whose modification time does not match the
    * modification time of the source associated with the entry). Invalid entries will be marked as
    * 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
@@ skipping 10 matching lines @@
         _sourceChanged(source);
         inconsistentCount++;
       }
       if (sourceEntry.exception != null) {
         if (!exists(source)) {
           missingSources.add(source);
         }
       }
     }
     int consistencyCheckEnd = JavaSystem.nanoTime();
-    PrintStringWriter writer = new PrintStringWriter();
-    writer.print("Consistency check took ");
-    writer.print((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
-    writer.println(" ms and found");
-    writer.print("  ");
-    writer.print(inconsistentCount);
-    writer.println(" inconsistent entries");
-    writer.print("  ");
-    writer.print(missingSources.length);
-    writer.println(" missing sources");
-    for (Source source in missingSources) {
-      writer.print("    ");
-      writer.println(source.fullName);
+    if (inconsistentCount > 0 || missingSources.length > 0) {
+      PrintStringWriter writer = new PrintStringWriter();
+      writer.print("Consistency check took ");
+      writer.print((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
+      writer.println(" ms and found");
+      writer.print("  ");
+      writer.print(inconsistentCount);
+      writer.println(" inconsistent entries");
+      writer.print("  ");
+      writer.print(missingSources.length);
+      writer.println(" missing sources");
+      for (Source source in missingSources) {
+        writer.print("    ");
+        writer.println(source.fullName);
+      }
+      _logInformation(writer.toString());
     }
-    _logInformation(writer.toString());
     return inconsistentCount > 0;
   }
 }
 
 /**
  * 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;
@@ skipping 18 matching lines @@
   @override
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this._recordParseHtmlTaskResults(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);
 
   @override
   DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task);
 
   @override
   HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this._recordResolveHtmlTaskResults(task);
 
   @override
   DartEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this._recordScanDartTaskResults(task);
 }
 
 class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this);
 
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
-    for (Source prioritySource in AnalysisContextImpl_this._priorityOrder) {
-      if (source == prioritySource) {
+    int priorityCount = AnalysisContextImpl_this._priorityOrder.length;
+    for (int i = 0; i < priorityCount; i++) {
+      if (source == AnalysisContextImpl_this._priorityOrder[i]) {
         return RetentionPriority.HIGH;
       }
     }
+    if (AnalysisContextImpl_this._neededForResolution != null && AnalysisContextImpl_this._neededForResolution.contains(source)) {
+      return RetentionPriority.HIGH;
+    }
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       if (_astIsNeeded(dartEntry)) {
         return RetentionPriority.MEDIUM;
       }
     }
     return RetentionPriority.LOW;
   }
 
   bool _astIsNeeded(DartEntry dartEntry) => dartEntry.hasInvalidData(DartEntry.HINTS) || dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
 }
 
 /**
+ * Instances of the class `LibraryPair` hold a library and a list of the (source, entry)
+ * pairs for compilation units in the library.
+ */
+class CycleBuilder_LibraryPair {
+  /**
+   * The library containing the compilation units.
+   */
+  ResolvableLibrary library;
+
+  /**
+   * The (source, entry) pairs representing the compilation units in the library.
+   */
+  List<CycleBuilder_SourceEntryPair> entryPairs;
+
+  /**
+   * Initialize a newly created pair.
+   *
+   * @param library the library containing the compilation units
+   * @param entryPairs the (source, entry) pairs representing the compilation units in the
+   *          library
+   */
+  CycleBuilder_LibraryPair(ResolvableLibrary library, List<CycleBuilder_SourceEntryPair> entryPairs) {
+    this.library = library;
+    this.entryPairs = entryPairs;
+  }
+}
+
+/**
+ * Instances of the class `SourceEntryPair` hold a source and the cache entry associated
+ * with that source. They are used to reduce the number of times an entry must be looked up in
+ * the [cache].
+ */
+class CycleBuilder_SourceEntryPair {
+  /**
+   * The source associated with the entry.
+   */
+  Source source;
+
+  /**
+   * The entry associated with the source.
+   */
+  DartEntry entry;
+
+  /**
+   * Initialize a newly created pair.
+   *
+   * @param source the source associated with the entry
+   * @param entry the entry associated with the source
+   */
+  CycleBuilder_SourceEntryPair(Source source, DartEntry entry) {
+    this.source = source;
+    this.entry = entry;
+  }
+}
+
+/**
+ * Instances of the class `CycleBuilder` are used to construct a list of the libraries that
+ * must be resolved together in order to resolve any one of the libraries.
+ */
+class AnalysisContextImpl_CycleBuilder {
+  final AnalysisContextImpl AnalysisContextImpl_this;
+
+  /**
+   * A table mapping the sources of the defining compilation units of libraries to the
+   * representation of the library that has the information needed to resolve the library.
+   */
+  Map<Source, ResolvableLibrary> _libraryMap = new Map<Source, ResolvableLibrary>();
+
+  /**
+   * The dependency graph used to compute the libraries in the cycle.
+   */
+  DirectedGraph<ResolvableLibrary> _dependencyGraph;
+
+  /**
+   * A list containing the libraries that are ready to be resolved.
+   */
+  List<ResolvableLibrary> _librariesInCycle;
+
+  /**
+   * The analysis task that needs to be performed before the cycle of libraries can be resolved,
+   * or `null` if the libraries are ready to be resolved.
+   */
+  AnalysisContextImpl_TaskData _taskData;
+
+  /**
+   * Initialize a newly created cycle builder.
+   */
+  AnalysisContextImpl_CycleBuilder(this.AnalysisContextImpl_this) : super();
+
+  /**
+   * Compute a list of the libraries that need to be resolved together in order to resolve the
+   * given library.
+   *
+   * @param librarySource the source of the library to be resolved
+   * @throws AnalysisException if the core library cannot be found
+   */
+  void computeCycleContaining(Source librarySource) {
+    //
+    // Create the object representing the library being resolved.
+    //
+    ResolvableLibrary targetLibrary = _createLibrary(librarySource);
+    //
+    // Compute the set of libraries that need to be resolved together.
+    //
+    _dependencyGraph = new DirectedGraph<ResolvableLibrary>();
+    _computeLibraryDependencies(targetLibrary);
+    if (_taskData != null) {
+      return;
+    }
+    _librariesInCycle = _dependencyGraph.findCycleContaining(targetLibrary);
+    //
+    // Ensure that all of the data needed to resolve them has been computed.
+    //
+    _ensureImportsAndExports();
+    if (_taskData != null) {
+      // At least one imported library needs to be resolved before the target library.
+      AnalysisTask task = _taskData.task;
+      if (task is ResolveDartLibraryTask) {
+        AnalysisContextImpl_this._workManager.addFirst(task.librarySource, SourcePriority.LIBRARY);
+      }
+      return;
+    }
+    _computePartsInCycle(librarySource);
+    if (_taskData != null) {
+      // At least one part needs to be parsed.
+      return;
+    }
+    // All of the AST's necessary to perform a resolution of the library cycle have been
+    // gathered, so it is no longer necessary to retain them in the cache.
+    AnalysisContextImpl_this._neededForResolution = null;
+  }
+
+  /**
+   * Return a list containing the libraries that are ready to be resolved (assuming that
+   * [getTaskData] returns `null`).
+   *
+   * @return the libraries that are ready to be resolved
+   */
+  List<ResolvableLibrary> get librariesInCycle => _librariesInCycle;
+
+  /**
+   * Return a representation of an analysis task that needs to be performed before the cycle of
+   * libraries can be resolved, or `null` if the libraries are ready to be resolved.
+   *
+   * @return the analysis task that needs to be performed before the cycle of libraries can be
+   *         resolved
+   */
+  AnalysisContextImpl_TaskData get taskData => _taskData;
+
+  /**
+   * Recursively traverse the libraries reachable from the given library, creating instances of
+   * the class [Library] to represent them, and record the references in the library
+   * objects.
+   *
+   * @param library the library to be processed to find libraries that have not yet been traversed
+   * @throws AnalysisException if some portion of the library graph could not be traversed
+   */
+  void _computeLibraryDependencies(ResolvableLibrary library) {
+    Source librarySource = library.librarySource;
+    DartEntry dartEntry = AnalysisContextImpl_this._getReadableDartEntry(librarySource);
+    List<Source> importedSources = _getSources(librarySource, dartEntry, DartEntry.IMPORTED_LIBRARIES);
+    if (_taskData != null) {
+      return;
+    }
+    List<Source> exportedSources = _getSources(librarySource, dartEntry, DartEntry.EXPORTED_LIBRARIES);
+    if (_taskData != null) {
+      return;
+    }
+    _computeLibraryDependenciesFromDirectives(library, importedSources, exportedSources);
+  }
+
+  /**
+   * Recursively traverse the libraries reachable from the given library, creating instances of
+   * the class [Library] to represent them, and record the references in the library
+   * objects.
+   *
+   * @param library the library to be processed to find libraries that have not yet been traversed
+   * @param importedSources an array containing the sources that are imported into the given
+   *          library
+   * @param exportedSources an array containing the sources that are exported from the given
+   *          library
+   */
+  void _computeLibraryDependenciesFromDirectives(ResolvableLibrary library, List<Source> importedSources, List<Source> exportedSources) {
+    int importCount = importedSources.length;
+    if (importCount > 0) {
+      List<ResolvableLibrary> importedLibraries = new List<ResolvableLibrary>();
+      bool explicitlyImportsCore = false;
+      for (int i = 0; i < importCount; i++) {
+        Source importedSource = importedSources[i];
+        if (importedSource == AnalysisContextImpl_this._coreLibrarySource) {
+          explicitlyImportsCore = true;
+        }
+        ResolvableLibrary importedLibrary = _libraryMap[importedSource];
+        if (importedLibrary == null) {
+          importedLibrary = _createLibraryOrNull(importedSource);
+          if (importedLibrary != null) {
+            _computeLibraryDependencies(importedLibrary);
+            if (_taskData != null) {
+              return;
+            }
+          }
+        }
+        if (importedLibrary != null) {
+          importedLibraries.add(importedLibrary);
+          _dependencyGraph.addEdge(library, importedLibrary);
+        }
+      }
+      library.explicitlyImportsCore = explicitlyImportsCore;
+      if (!explicitlyImportsCore && AnalysisContextImpl_this._coreLibrarySource != library.librarySource) {
+        ResolvableLibrary importedLibrary = _libraryMap[AnalysisContextImpl_this._coreLibrarySource];
+        if (importedLibrary == null) {
+          importedLibrary = _createLibraryOrNull(AnalysisContextImpl_this._coreLibrarySource);
+          if (importedLibrary != null) {
+            _computeLibraryDependencies(importedLibrary);
+            if (_taskData != null) {
+              return;
+            }
+          }
+        }
+        if (importedLibrary != null) {
+          importedLibraries.add(importedLibrary);
+          _dependencyGraph.addEdge(library, importedLibrary);
+        }
+      }
+      library.importedLibraries = new List.from(importedLibraries);
+    } else {
+      library.explicitlyImportsCore = false;
+      ResolvableLibrary importedLibrary = _libraryMap[AnalysisContextImpl_this._coreLibrarySource];
+      if (importedLibrary == null) {
+        importedLibrary = _createLibraryOrNull(AnalysisContextImpl_this._coreLibrarySource);
+        if (importedLibrary != null) {
+          _computeLibraryDependencies(importedLibrary);
+          if (_taskData != null) {
+            return;
+          }
+        }
+      }
+      if (importedLibrary != null) {
+        _dependencyGraph.addEdge(library, importedLibrary);
+        library.importedLibraries = <ResolvableLibrary> [importedLibrary];
+      }
+    }
+    int exportCount = exportedSources.length;
+    if (exportCount > 0) {
+      List<ResolvableLibrary> exportedLibraries = new List<ResolvableLibrary>();
+      for (int i = 0; i < exportCount; i++) {
+        Source exportedSource = exportedSources[i];
+        ResolvableLibrary exportedLibrary = _libraryMap[exportedSource];
+        if (exportedLibrary == null) {
+          exportedLibrary = _createLibraryOrNull(exportedSource);
+          if (exportedLibrary != null) {
+            _computeLibraryDependencies(exportedLibrary);
+            if (_taskData != null) {
+              return;
+            }
+          }
+        }
+        if (exportedLibrary != null) {
+          exportedLibraries.add(exportedLibrary);
+          _dependencyGraph.addEdge(library, exportedLibrary);
+        }
+      }
+      library.exportedLibraries = new List.from(exportedLibraries);
+    }
+  }
+
+  /**
+   * Gather the resolvable AST structures for each of the compilation units in each of the
+   * libraries in the cycle. This is done in two phases: first we ensure that we have cached an
+   * AST structure for each compilation unit, then we gather them. We split the work this way
+   * because getting the AST structures can change the state of the cache in such a way that we
+   * would have more work to do if any compilation unit didn't have a resolvable AST structure.
+   */
+  void _computePartsInCycle(Source librarySource) {
+    int count = _librariesInCycle.length;
+    List<CycleBuilder_LibraryPair> libraryData = new List<CycleBuilder_LibraryPair>();
+    for (int i = 0; i < count; i++) {
+      ResolvableLibrary library = _librariesInCycle[i];
+      libraryData.add(new CycleBuilder_LibraryPair(library, _ensurePartsInLibrary(library)));
+    }
+    AnalysisContextImpl_this._neededForResolution = _gatherSources(libraryData);
+    if (AnalysisContextImpl._TRACE_PERFORM_TASK) {
+      print("  preserve resolution data for ${AnalysisContextImpl_this._neededForResolution.length} sources while resolving ${librarySource.fullName}");
+    }
+    if (_taskData != null) {
+      return;
+    }
+    for (int i = 0; i < count; i++) {
+      _computePartsInLibrary(libraryData[i]);
+    }
+  }
+
+  /**
+   * Gather the resolvable compilation units for each of the compilation units in the specified
+   * library.
+   *
+   * @param libraryPair a holder containing both the library and a list of (source, entry) pairs
+   *          for all of the compilation units in the library
+   */
+  void _computePartsInLibrary(CycleBuilder_LibraryPair libraryPair) {
+    ResolvableLibrary library = libraryPair.library;
+    List<CycleBuilder_SourceEntryPair> entryPairs = libraryPair.entryPairs;
+    int count = entryPairs.length;
+    List<ResolvableCompilationUnit> units = new List<ResolvableCompilationUnit>(count);
+    for (int i = 0; i < count; i++) {
+      CycleBuilder_SourceEntryPair entryPair = entryPairs[i];
+      Source source = entryPair.source;
+      DartEntryImpl dartCopy = entryPair.entry.writableCopy;
+      units[i] = new ResolvableCompilationUnit.con2(dartCopy.modificationTime, dartCopy.resolvableCompilationUnit, source);
+      AnalysisContextImpl_this._cache.put(source, dartCopy);
+    }
+    library.resolvableCompilationUnits = units;
+  }
+
+  /**
+   * Create an object to represent the information about the library defined by the compilation
+   * unit with the given source.
+   *
+   * @param librarySource the source of the library's defining compilation unit
+   * @return the library object that was created
+   */
+  ResolvableLibrary _createLibrary(Source librarySource) {
+    ResolvableLibrary library = new ResolvableLibrary(librarySource);
+    SourceEntry sourceEntry = AnalysisContextImpl_this._cache.get(librarySource);
+    if (sourceEntry is DartEntry) {
+      LibraryElementImpl libraryElement = sourceEntry.getValue(DartEntry.ELEMENT) as LibraryElementImpl;
+      if (libraryElement != null) {
+        library.libraryElement = libraryElement;
+      }
+    }
+    _libraryMap[librarySource] = library;
+    return library;
+  }
+
+  /**
+   * Create an object to represent the information about the library defined by the compilation
+   * unit with the given source.
+   *
+   * @param librarySource the source of the library's defining compilation unit
+   * @return the library object that was created
+   */
+  ResolvableLibrary _createLibraryOrNull(Source librarySource) {
+    if (!AnalysisContextImpl_this.exists(librarySource)) {
+      return null;
+    }
+    ResolvableLibrary library = new ResolvableLibrary(librarySource);
+    SourceEntry sourceEntry = AnalysisContextImpl_this._cache.get(librarySource);
+    if (sourceEntry is DartEntry) {
+      LibraryElementImpl libraryElement = sourceEntry.getValue(DartEntry.ELEMENT) as LibraryElementImpl;
+      if (libraryElement != null) {
+        library.libraryElement = libraryElement;
+      }
+    }
+    _libraryMap[librarySource] = library;
+    return library;
+  }
+
+  /**
+   * Ensure that all of the libraries that are exported by the given library (but are not
+   * themselves in the cycle) have element models built for them.
+   *
+   * @param library the library being tested
+   */
+  void _ensureExports(ResolvableLibrary library, Set<Source> visitedLibraries) {
+    List<ResolvableLibrary> dependencies = library.exports;
+    int dependencyCount = dependencies.length;
+    for (int i = 0; i < dependencyCount; i++) {
+      ResolvableLibrary dependency = dependencies[i];
+      if (!_librariesInCycle.contains(dependency) && visitedLibraries.add(dependency.librarySource)) {
+        if (dependency.libraryElement == null) {
+          Source dependencySource = dependency.librarySource;
+          AnalysisContextImpl_this._workManager.addFirst(dependencySource, SourcePriority.LIBRARY);
+          if (_taskData == null) {
+            _taskData = AnalysisContextImpl_this._createResolveDartLibraryTask(dependencySource, AnalysisContextImpl_this._getReadableDartEntry(dependencySource));
+          }
+        } else {
+          _ensureExports(dependency, visitedLibraries);
+        }
+      }
+    }
+  }
+
+  /**
+   * Ensure that all of the libraries that are exported by the given library (but are not
+   * themselves in the cycle) have element models built for them.
+   *
+   * @param library the library being tested
+   * @throws MissingDataException if there is at least one library being depended on that does not
+   *           have an element model built for it
+   */
+  void _ensureImports(ResolvableLibrary library) {
+    List<ResolvableLibrary> dependencies = library.imports;
+    int dependencyCount = dependencies.length;
+    for (int i = 0; i < dependencyCount; i++) {
+      ResolvableLibrary dependency = dependencies[i];
+      if (!_librariesInCycle.contains(dependency) && dependency.libraryElement == null) {
+        Source dependencySource = dependency.librarySource;
+        AnalysisContextImpl_this._workManager.addFirst(dependencySource, SourcePriority.LIBRARY);
+        if (_taskData == null) {
+          _taskData = AnalysisContextImpl_this._createResolveDartLibraryTask(dependencySource, AnalysisContextImpl_this._getReadableDartEntry(dependencySource));
+        }
+      }
+    }
+  }
+
+  /**
+   * Ensure that all of the libraries that are either imported or exported by libraries in the
+   * cycle (but are not themselves in the cycle) have element models built for them.
+   */
+  void _ensureImportsAndExports() {
+    Set<Source> visitedLibraries = new Set<Source>();
+    int libraryCount = _librariesInCycle.length;
+    for (int i = 0; i < libraryCount; i++) {
+      ResolvableLibrary library = _librariesInCycle[i];
+      _ensureImports(library);
+      _ensureExports(library, visitedLibraries);
+    }
+  }
+
+  /**
+   * Ensure that there is a resolvable compilation unit available for all of the compilation units
+   * in the given library.
+   *
+   * @param library the library for which resolvable compilation units must be available
+   * @return a list of (source, entry) pairs for all of the compilation units in the library
+   */
+  List<CycleBuilder_SourceEntryPair> _ensurePartsInLibrary(ResolvableLibrary library) {
+    List<CycleBuilder_SourceEntryPair> pairs = new List<CycleBuilder_SourceEntryPair>();
+    Source librarySource = library.librarySource;
+    DartEntry libraryEntry = AnalysisContextImpl_this._getReadableDartEntry(librarySource);
+    _ensureResolvableCompilationUnit(librarySource, libraryEntry);
+    pairs.add(new CycleBuilder_SourceEntryPair(librarySource, libraryEntry));
+    List<Source> partSources = _getSources(librarySource, libraryEntry, DartEntry.INCLUDED_PARTS);
+    int count = partSources.length;
+    for (int i = 0; i < count; i++) {
+      Source partSource = partSources[i];
+      DartEntry partEntry = AnalysisContextImpl_this._getReadableDartEntry(partSource);
+      if (partEntry != null) {
+        _ensureResolvableCompilationUnit(partSource, partEntry);
+        pairs.add(new CycleBuilder_SourceEntryPair(partSource, partEntry));
+      }
+    }
+    return pairs;
+  }
+
+  /**
+   * Ensure that there is a resolvable compilation unit available for the given source.
+   *
+   * @param source the source for which a resolvable compilation unit must be available
+   * @param dartEntry the entry associated with the source
+   */
+  void _ensureResolvableCompilationUnit(Source source, DartEntry dartEntry) {
+    if (!dartEntry.hasResolvableCompilationUnit) {
+      if (_taskData == null) {
+        _taskData = AnalysisContextImpl_this._createParseDartTask(source, dartEntry);
+      }
+    }
+  }
+
+  Set<Source> _gatherSources(List<CycleBuilder_LibraryPair> libraryData) {
+    int libraryCount = libraryData.length;
+    Set<Source> sources = new Set<Source>();
+    for (int i = 0; i < libraryCount; i++) {
+      List<CycleBuilder_SourceEntryPair> entryPairs = libraryData[i].entryPairs;
+      int entryCount = entryPairs.length;
+      for (int j = 0; j < entryCount; j++) {
+        sources.add(entryPairs[j].source);
+      }
+    }
+    return sources;
+  }
+
+  /**
+   * Return the sources described by the given descriptor.
+   *
+   * @param source the source with which the sources are associated
+   * @param dartEntry the entry corresponding to the source
+   * @param descriptor the descriptor indicating which sources are to be returned
+   * @return the sources described by the given descriptor
+   */
+  List<Source> _getSources(Source source, DartEntry dartEntry, DataDescriptor<List<Source>> descriptor) {
+    if (dartEntry == null) {
+      return Source.EMPTY_ARRAY;
+    }
+    CacheState exportState = dartEntry.getState(descriptor);
+    if (identical(exportState, CacheState.ERROR)) {
+      return Source.EMPTY_ARRAY;
+    } else if (exportState != CacheState.VALID) {
+      if (_taskData == null) {
+        _taskData = AnalysisContextImpl_this._createParseDartTask(source, dartEntry);
+      }
+      return Source.EMPTY_ARRAY;
+    }
+    return dartEntry.getValue(descriptor);
+  }
+}
+
+/**
  * Instances of the class `TaskData` represent information about the next task to be
  * performed. Each data has an implicit associated source: the source that might need to be
  * analyzed. There are essentially three states that can be represented:
  * * If [getTask] returns a non-`null` value, then that is the task that should
  * be executed to further analyze the associated source.
  * * Otherwise, if [isBlocked] returns `true`, then there is no work that can be
  * done, but analysis for the associated source is not complete.
  * * Otherwise, [getDependentSource] should return a source that needs to be analyzed
  * before the analysis of the associated source can be completed.
  */
@@ skipping 22 matching lines @@
   }
 
   /**
    * Return `true` if the associated source is blocked waiting for its contents to be
    * loaded.
    *
    * @return `true` if the associated source is blocked waiting for its contents to be
    *         loaded
    */
   bool get isBlocked => _blocked;
+
+  @override
+  String toString() {
+    if (task == null) {
+      return "blocked: ${_blocked}";
+    }
+    return task.toString();
+  }
 }
 
 /**
  * Instances of the class `AnalysisErrorInfoImpl` represent the analysis errors and line info
  * associated with a source.
  */
 class AnalysisErrorInfoImpl implements AnalysisErrorInfo {
   /**
    * The analysis errors associated with a source, or `null` if there are no errors.
    */
@@ skipping 868 matching lines @@
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getAnalysisOptions");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.analysisOptions;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
+  AngularApplication getAngularApplicationWithHtml(Source htmlSource) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getAngularApplication");
+    _checkThread(instrumentation);
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      return _basis.getAngularApplicationWithHtml(htmlSource);
+    } finally {
+      instrumentation.log();
+    }
+  }
+
   /**
    * @return the underlying [AnalysisContext].
    */
   AnalysisContext get basis => _basis;
 
   @override
   CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getCompilationUnitElement");
     _checkThread(instrumentation);
     try {
@@ skipping 149 matching lines @@
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
+  List<Source> getLibrariesReferencedFromHtml(Source htmlSource) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrariesReferencedFromHtml");
+    _checkThread(instrumentation);
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      return _basis.getLibrariesReferencedFromHtml(htmlSource);
+    } finally {
+      instrumentation.log();
+    }
+  }
+
+  @override
   LibraryElement getLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibraryElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getLibraryElement(source);
     } finally {
       instrumentation.log();
     }
   }
@@ skipping 85 matching lines @@
       instrumentation.metric3("contextId", _contextId);
       return _basis.getResolvedHtmlUnit(htmlSource);
     } finally {
       instrumentation.log2(2);
     }
   }
 
   @override
   SourceFactory get sourceFactory {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getSourceFactory");
-    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.sourceFactory;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   @override
   AnalysisContentStatistics get statistics => _basis.statistics;
 
   @override
   TypeProvider get typeProvider => _basis.typeProvider;
 
   @override
-  TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) => _basis.internalResolveCompilationUnit(unitSource, libraryElement);
-
-  @override
   bool isClientLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isClientLibrary");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isClientLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
@@ skipping 270 matching lines @@
   /**
    * Returns a type provider for this context or throws an exception if dart:core cannot be
    * resolved.
    *
    * @return the type provider (not `null`)
    * @throws AnalysisException if dart:core cannot be resolved
    */
   TypeProvider get typeProvider;
 
   /**
-   * Return a time-stamped fully-resolved compilation unit for the given source in the given
-   * library.
-   *
-   * @param unitSource the source of the compilation unit for which a resolved AST structure is to
-   *          be returned
-   * @param libraryElement the element representing the library in which the compilation unit is to
-   *          be resolved
-   * @return a time-stamped fully-resolved compilation unit for the source
-   * @throws AnalysisException if the resolved compilation unit could not be computed
-   */
-  TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement);
-
-  /**
    * Given a table mapping the source for the libraries represented by the corresponding elements to
    * the elements representing the libraries, record those mappings.
    *
    * @param elementMap a table mapping the source for the libraries represented by the elements to
    *          the elements representing the libraries
    */
   void recordLibraryElements(Map<Source, LibraryElement> elementMap);
 }
 
 /**
@@ skipping 430 matching lines @@
    * Record that the given source is fully analyzed.
    *
    * @param source the source that is fully analyzed
    */
   void remove(Source source) {
     int queueCount = _workQueues.length;
     for (int i = 0; i < queueCount; i++) {
       _workQueues[i].remove(source);
     }
   }
+
+  @override
+  String toString() {
+    JavaStringBuilder builder = new JavaStringBuilder();
+    List<SourcePriority> priorities = SourcePriority.values;
+    bool needsSeparator = false;
+    int queueCount = _workQueues.length;
+    for (int i = 0; i < queueCount; i++) {
+      List<Source> queue = _workQueues[i];
+      if (!queue.isEmpty) {
+        if (needsSeparator) {
+          builder.append("; ");
+        }
+        builder.append(priorities[i]);
+        builder.append(": ");
+        int queueSize = queue.length;
+        for (int j = 0; j < queueSize; j++) {
+          if (j > 0) {
+            builder.append(", ");
+          }
+          builder.append(queue[j].fullName);
+        }
+        needsSeparator = true;
+      }
+    }
+    return builder.toString();
+  }
 }
 
 /**
  * Instances of the class `WorkIterator` implement an iterator that returns the sources in a
  * work manager in the order in which they are to be analyzed.
  */
 class WorkManager_WorkIterator {
   final WorkManager WorkManager_this;
 
   /**
@@ skipping 1138 matching lines @@
         }
       }
     }
     //
     for (AngularPropertyElement property in _element.properties) {
       // prepare attribute name
       String name = property.name;
       if (name == ".") {
         name = selectorAttributeName;
       }
-      // resolve attribute expression
+      // prepare attribute
       ht.XmlAttributeNode attribute = node.getAttribute(name);
-      if (attribute != null) {
-        // if not resolved as the selector, resolve as a property
-        if (name != selectorAttributeName) {
-          attribute.element = property;
-        }
-        // resolve if binding
-        if (property.propertyKind != AngularPropertyKind.ATTR) {
-          resolver._pushNameScope();
-          try {
-            _onNgEventDirective(resolver);
-            AngularExpression expression = parseAngularExpression(resolver, attribute);
-            resolver._resolveExpression(expression);
-            setAngularExpression(attribute, expression);
-          } finally {
-            resolver._popNameScope();
-          }
+      if (attribute == null) {
+        continue;
+      }
+      // if not resolved as the selector, resolve as a property
+      if (name != selectorAttributeName) {
+        attribute.element = property;
+      }
+      // skip if attribute has no value
+      if (!NgDirectiveProcessor.hasValue(attribute)) {
+        continue;
+      }
+      // resolve if binding
+      if (property.propertyKind != AngularPropertyKind.ATTR) {
+        resolver._pushNameScope();
+        try {
+          _onNgEventDirective(resolver);
+          AngularExpression expression = parseAngularExpression(resolver, attribute);
+          resolver._resolveExpression(expression);
+          setAngularExpression(attribute, expression);
+        } finally {
+          resolver._popNameScope();
         }
       }
     }
   }
 
   @override
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 
   /**
    * Support for <code>$event</code> variable in <code>NgEventDirective</code>.
    */
   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.
  */
 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);
 
   AngularExpression parseAngularExpression(AngularHtmlUnitResolver resolver, ht.XmlAttributeNode attribute) {
     Token token = _scanAttribute(resolver, attribute);
     return resolver._parseAngularExpressionInToken(token);
   }
 
   Expression parseDartExpression(AngularHtmlUnitResolver resolver, ht.XmlAttributeNode attribute) {
@@ skipping 264 matching lines @@
   /**
    * Visit a [ResolveAngularEntryHtmlTask].
    *
    * @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 visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task);
 
   /**
+   * Visit a [ResolveDartLibraryCycleTask].
+   *
+   * @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 visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task);
+
+  /**
    * Visit a [ResolveDartLibraryTask].
    *
    * @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 visitResolveDartLibraryTask(ResolveDartLibraryTask task);
 
   /**
    * Visit a [ResolveDartUnitTask].
@@ skipping 27 matching lines @@
  * 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.
    */
   Source source;
 
   /**
+   * The time at which the contents of the source were last modified.
+   */
+  int modificationTime = 0;
+
+  /**
+   * The compilation unit used to resolve the dependencies.
+   */
+  CompilationUnit _unit;
+
+  /**
    * The element model for the library containing the source.
    */
   LibraryElement libraryElement;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  int _modificationTime = -1;
-
-  /**
    * The errors that were generated for the source.
    */
   List<AnalysisError> _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 for which errors and warnings are to be produced
+   * @param modificationTime the time at which the contents of the source were last modified
+   * @param unit the compilation unit used to resolve the dependencies
    * @param libraryElement the element model for the library containing the source
    */
-  GenerateDartErrorsTask(InternalAnalysisContext context, Source source, LibraryElement libraryElement) : super(context) {
+  GenerateDartErrorsTask(InternalAnalysisContext context, Source source, int modificationTime, CompilationUnit unit, LibraryElement libraryElement) : super(context) {
     this.source = source;
+    this.modificationTime = modificationTime;
+    this._unit = unit;
     this.libraryElement = libraryElement;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartErrorsTask(this);
 
   /**
    * Return the errors that were generated for the source.
    *
    * @return the errors that were generated for the source
    */
   List<AnalysisError> get errors => _errors;
 
-  /**
-   * Return the time at which the contents of the source that was verified were last modified, or a
-   * negative value if the task has not yet been performed or if an exception occurred.
-   *
-   * @return the time at which the contents of the source that was verified were last modified
-   */
-  int get modificationTime => _modificationTime;
-
   @override
   String get taskDescription => "generate errors and warnings for ${source.fullName}";
 
   @override
   void internalPerform() {
-    InternalAnalysisContext context = this.context;
-    TimestampedData<CompilationUnit> data = context.internalResolveCompilationUnit(source, libraryElement);
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
     try {
-      _modificationTime = data.modificationTime;
-      CompilationUnit unit = data.data;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       TypeProvider typeProvider = context.typeProvider;
       //
       // Use the ConstantVerifier to verify the use of constants. This needs to happen before using
       // the ErrorVerifier because some error codes need the computed constant values.
       //
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
-      unit.accept(constantVerifier);
+      _unit.accept(constantVerifier);
       //
       // Use the ErrorVerifier to compute the rest of the errors.
       //
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, libraryElement, typeProvider, new InheritanceManager(libraryElement));
-      unit.accept(errorVerifier);
+      _unit.accept(errorVerifier);
       _errors = errorListener.getErrorsForSource(source);
     } finally {
       timeCounter.stop();
     }
   }
 }
 
 /**
  * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library.
  */
 class GenerateDartHintsTask extends AnalysisTask {
   /**
+   * The compilation units that comprise the library, with the defining compilation unit appearing
+   * first in the array.
+   */
+  List<TimestampedData<CompilationUnit>> _units;
+
+  /**
    * The element model for the library being analyzed.
    */
   LibraryElement libraryElement;
 
   /**
    * A table mapping the sources that were analyzed to the hints that were generated for the
    * sources.
    */
   Map<Source, TimestampedData<List<AnalysisError>>> _hintMap;
 
   /**
    * 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 units the compilation units that comprise the library, with the defining compilation
+   *          unit appearing first in the array
    * @param libraryElement the element model for the library being analyzed
    */
-  GenerateDartHintsTask(InternalAnalysisContext context, LibraryElement libraryElement) : super(context) {
+  GenerateDartHintsTask(InternalAnalysisContext context, List<TimestampedData<CompilationUnit>> units, LibraryElement libraryElement) : super(context) {
+    this._units = units;
     this.libraryElement = libraryElement;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartHintsTask(this);
 
   /**
    * Return a table mapping the sources that were analyzed to the hints that were generated for the
    * sources, or `null` if the task has not been performed or if the analysis did not complete
    * normally.
    *
    * @return a table mapping the sources that were analyzed to the hints that were generated for the
    *         sources
    */
   Map<Source, TimestampedData<List<AnalysisError>>> get hintMap => _hintMap;
 
   @override
   String get taskDescription {
     Source librarySource = libraryElement.source;
     if (librarySource == null) {
       return "generate Dart hints for library without source";
     }
     return "generate Dart hints for ${librarySource.fullName}";
   }
 
   @override
   void internalPerform() {
-    RecordingErrorListener errorListener = new RecordingErrorListener();
-    List<CompilationUnitElement> parts = libraryElement.parts;
-    int partCount = parts.length;
-    List<CompilationUnit> compilationUnits = new List<CompilationUnit>(partCount + 1);
-    Map<Source, TimestampedData<CompilationUnit>> timestampMap = new Map<Source, TimestampedData<CompilationUnit>>();
     //
-    // Get all of the (fully resolved) compilation units that will be analyzed.
+    // Gather the compilation units.
     //
-    Source unitSource = libraryElement.definingCompilationUnit.source;
-    TimestampedData<CompilationUnit> resolvedUnit = _getCompilationUnit(unitSource);
-    timestampMap[unitSource] = resolvedUnit;
-    CompilationUnit unit = resolvedUnit.data;
-    if (unit == null) {
-      throw new AnalysisException.con1("Internal error: GenerateDartHintsTask failed to access resolved compilation unit for ${unitSource.fullName}");
-    }
-    compilationUnits[0] = unit;
-    for (int i = 0; i < partCount; i++) {
-      unitSource = parts[i].source;
-      resolvedUnit = _getCompilationUnit(unitSource);
-      timestampMap[unitSource] = resolvedUnit;
-      unit = resolvedUnit.data;
-      if (unit == null) {
-        throw new AnalysisException.con1("Internal error: GenerateDartHintsTask failed to access resolved compilation unit for ${unitSource.fullName}");
-      }
-      compilationUnits[i + 1] = unit;
+    int unitCount = _units.length;
+    List<CompilationUnit> compilationUnits = new List<CompilationUnit>(unitCount);
+    for (int i = 0; i < unitCount; i++) {
+      compilationUnits[i] = _units[i].data;
     }
     //
     // Analyze all of the units.
     //
+    RecordingErrorListener errorListener = new RecordingErrorListener();
     HintGenerator hintGenerator = new HintGenerator(compilationUnits, context, errorListener);
     hintGenerator.generateForLibrary();
     //
     // Store the results.
     //
     _hintMap = new Map<Source, TimestampedData<List<AnalysisError>>>();
-    for (MapEntry<Source, TimestampedData<CompilationUnit>> entry in getMapEntrySet(timestampMap)) {
-      Source source = entry.getKey();
-      TimestampedData<CompilationUnit> unitData = entry.getValue();
+    for (int i = 0; i < unitCount; i++) {
+      int modificationTime = _units[i].modificationTime;
+      Source source = _units[i].data.element.source;
       List<AnalysisError> errors = errorListener.getErrorsForSource(source);
-      _hintMap[source] = new TimestampedData<List<AnalysisError>>(unitData.modificationTime, errors);
+      _hintMap[source] = new TimestampedData<List<AnalysisError>>(modificationTime, errors);
     }
   }
-
-  /**
-   * Return the resolved compilation unit associated with the given source.
-   *
-   * @param unitSource the source for the compilation unit whose resolved AST is to be returned
-   * @return the resolved compilation unit associated with the given source
-   * @throws AnalysisException if the resolved compilation unit could not be computed
-   */
-  TimestampedData<CompilationUnit> _getCompilationUnit(Source unitSource) => context.internalResolveCompilationUnit(unitSource, libraryElement);
 }
 
 /**
  * Instances of the class `GetContentTask` get the contents of a source.
  */
 class GetContentTask extends AnalysisTask {
   /**
    * The source to be read.
    */
   Source source;
@@ skipping 182 matching lines @@
   int modificationTime = 0;
 
   /**
    * The head of the token stream used for parsing.
    */
   Token _tokenStream;
 
   /**
    * The line information associated with the source.
    */
-  LineInfo _lineInfo;
+  LineInfo lineInfo;
 
   /**
    * The compilation unit that was produced by parsing the source.
    */
   CompilationUnit _unit;
 
   /**
    * A flag indicating whether the source contains a 'library' directive.
    */
   bool _containsLibraryDirective = false;
@@ skipping 34 matching lines @@
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param modificationTime the time at which the contents of the source were last modified
    * @param tokenStream the head of the token stream used for parsing
    * @param lineInfo the line information associated with the source
    */
   ParseDartTask(InternalAnalysisContext context, Source source, int modificationTime, Token tokenStream, LineInfo lineInfo) : super(context) {
     this.source = source;
     this.modificationTime = modificationTime;
     this._tokenStream = tokenStream;
-    this._lineInfo = lineInfo;
+    this.lineInfo = lineInfo;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this);
 
   /**
    * Return the compilation unit that was produced by parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the compilation unit that was produced by parsing the source
@@ skipping 60 matching lines @@
   void internalPerform() {
     //
     // Then parse the token stream.
     //
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       Parser parser = new Parser(source, errorListener);
       parser.parseFunctionBodies = context.analysisOptions.analyzeFunctionBodies;
       _unit = parser.parseCompilationUnit(_tokenStream);
-      _unit.lineInfo = _lineInfo;
+      _unit.lineInfo = lineInfo;
       _errors = errorListener.getErrorsForSource(source);
       for (Directive directive in _unit.directives) {
         if (directive is ExportDirective) {
           Source exportSource = _resolveSource(source, directive, errorListener);
           if (exportSource != null) {
             _exportedSources.add(exportSource);
           }
         } else if (directive is ImportDirective) {
           Source importSource = _resolveSource(source, directive, errorListener);
           if (importSource != null) {
             _importedSources.add(importSource);
           }
         } else if (directive is LibraryDirective) {
           _containsLibraryDirective = true;
         } else if (directive is PartDirective) {
           Source partSource = _resolveSource(source, directive, errorListener);
-          if (partSource != null) {
+          if (partSource != null && partSource != source) {
             _includedSources.add(partSource);
           }
         } else if (directive is PartOfDirective) {
           _containsPartOfDirective = true;
         }
       }
     } finally {
       timeCounterParse.stop();
     }
   }
@@ skipping 418 matching lines @@
     //
     // Remember the resolved unit.
     //
     _resolvedUnit = _unit;
   }
 }
 
 /**
  * Instances of the class `ResolveDartLibraryTask` resolve a specific Dart library.
  */
+class ResolveDartLibraryCycleTask extends AnalysisTask {
+  /**
+   * The source representing the file whose compilation unit is to be returned. TODO(brianwilkerson)
+   * This should probably be removed, but is being left in for now to ease the transition.
+   */
+  Source unitSource;
+
+  /**
+   * The source representing the library to be resolved.
+   */
+  Source librarySource;
+
+  /**
+   * The libraries that are part of the cycle containing the library to be resolved.
+   */
+  List<ResolvableLibrary> _librariesInCycle;
+
+  /**
+   * The library resolver holding information about the libraries that were resolved.
+   */
+  LibraryResolver2 _resolver;
+
+  /**
+   * 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 unitSource the source representing the file whose compilation unit is to be returned
+   * @param librarySource the source representing the library to be resolved
+   * @param librariesInCycle the libraries that are part of the cycle containing the library to be
+   *          resolved
+   */
+  ResolveDartLibraryCycleTask(InternalAnalysisContext context, Source unitSource, Source librarySource, List<ResolvableLibrary> librariesInCycle) : super(context) {
+    this.unitSource = unitSource;
+    this.librarySource = librarySource;
+    this._librariesInCycle = librariesInCycle;
+  }
+
+  @override
+  accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartLibraryCycleTask(this);
+
+  /**
+   * Return the library resolver holding information about the libraries that were resolved.
+   *
+   * @return the library resolver holding information about the libraries that were resolved
+   */
+  LibraryResolver2 get libraryResolver => _resolver;
+
+  @override
+  String get taskDescription {
+    if (librarySource == null) {
+      return "resolve library null source";
+    }
+    return "resolve library ${librarySource.fullName}";
+  }
+
+  @override
+  void internalPerform() {
+    _resolver = new LibraryResolver2(context);
+    _resolver.resolveLibrary(librarySource, _librariesInCycle);
+  }
+}
+
+/**
+ * Instances of the class `ResolveDartLibraryTask` resolve a specific Dart library.
+ */
 class ResolveDartLibraryTask extends AnalysisTask {
   /**
    * The source representing the file whose compilation unit is to be returned.
    */
   Source unitSource;
 
   /**
    * The source representing the library to be resolved.
    */
   Source librarySource;
@@ skipping 462 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }