Roll Observatory packages and add a roll script

packages/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 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/cancelable_future.dart';
 import 'package:analyzer/src/context/cache.dart' as cache;
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/incremental_resolution_validator.dart';
@@ skipping 184 matching lines @@
           }
         }
         _partitions[i].put(source, entry);
         return;
       }
     }
   }
 
   /**
    * Remove all information related to the given [source] from this cache.
+   * Return the entry associated with the source, or `null` if there was cache
+   * entry for the source.
    */
-  void remove(Source source) {
+  SourceEntry remove(Source source) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
         if (_TRACE_CHANGES) {
           try {
             AnalysisEngine.instance.logger.logInformation(
                 "Removed the cache entry for ${source.fullName}'.");
           } catch (exception) {
             // Ignored
             JavaSystem.currentTimeMillis();
           }
         }
-        _partitions[i].remove(source);
-        return;
+        return _partitions[i].remove(source);
       }
     }
+    return null;
   }
 
   /**
    * Record that the AST associated with the given [source] was just removed
    * from the cache.
    */
   void removedAst(Source source) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
@@ skipping 106 matching lines @@
    */
   DeclaredVariables get declaredVariables;
 
   /**
    * Return a list containing all of the sources known to this context that
    * represent HTML files. The contents of the list can be incomplete.
    */
   List<Source> get htmlSources;
 
   /**
+   * The stream that is notified when a source either starts or stops being
+   * analyzed implicitly.
+   */
+  Stream<ImplicitAnalysisEvent> get implicitAnalysisEvents;
+
+  /**
    * Returns `true` if this context was disposed using [dispose].
    */
   bool get isDisposed;
 
   /**
    * Return a list containing all of the sources known to this context that
    * represent the defining compilation unit of a library that can be run within
    * a browser. The sources that are returned represent libraries that have a
    * 'main' method and are either referenced by an HTML file or import, directly
    * or indirectly, a client-only library. The contents of the list can be
@@ skipping 51 matching lines @@
    */
   List<Source> get sources;
 
   /**
    * Return a type provider for this context or throw [AnalysisException] if
    * either `dart:core` or `dart:async` cannot be resolved.
    */
   TypeProvider get typeProvider;
 
   /**
+   * Return a type system for this context.
+   */
+  TypeSystem get typeSystem;
+
+  /**
    * Add the given [listener] to the list of objects that are to be notified
    * when various analysis results are produced in this context.
    */
   void addListener(AnalysisListener listener);
 
   /**
    * Apply the given [delta] to change the level of analysis that will be
    * performed for the sources known to this context.
    */
   void applyAnalysisDelta(AnalysisDelta delta);
@@ skipping 104 matching lines @@
    * If the resolved AST can't be computed for some reason, the future will be
    * completed with an error.  One possible error is AnalysisNotScheduledError,
    * which means that the resolved AST can't be computed because the given
    * source file is not scheduled to be analyzed within the context of the
    * given library.
    */
   CancelableFuture<CompilationUnit> computeResolvedCompilationUnitAsync(
       Source source, Source librarySource);
 
   /**
+   * Perform work until the given [result] has been computed for the given
+   * [target]. Return the computed value.
+   */
+  Object /*V*/ computeResult(
+      AnalysisTarget target, ResultDescriptor /*<V>*/ result);
+
+  /**
    * Notifies the context that the client is going to stop using this context.
    */
   void dispose();
 
   /**
    * Return `true` if the given [source] exists.
    *
    * This method should be used rather than the method [Source.exists] because
    * contexts can have local overrides of the content of a source that the
    * source is not aware of and a source with local content is considered to
@@ skipping 145 matching lines @@
   /**
    * Return the fully resolved HTML unit defined by the given [htmlSource], or
    * `null` if the resolved unit is not already computed.
    *
    * See [resolveHtmlUnit].
    */
   @deprecated
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource);
 
   /**
+   * Return the value of the given [result] for the given [target].
+   *
+   * If the corresponding [target] does not exist, or the [result] is not
+   * computed yet, then the default value is returned.
+   */
+  Object /*V*/ getResult(
+      AnalysisTarget target, ResultDescriptor /*<V>*/ result);
+
+  /**
    * Return a list of the sources being analyzed in this context whose full path
    * is equal to the given [path].
    */
   List<Source> getSourcesWithFullName(String path);
 
   /**
    * Invalidates hints in the given [librarySource] and included parts.
    */
   void invalidateLibraryHints(Source librarySource);
 
@@ skipping 286 matching lines @@
    * Cached information used in incremental analysis or `null` if none.
    */
   IncrementalAnalysisCache _incrementalAnalysisCache;
 
   /**
    * The [TypeProvider] for this context, `null` if not yet created.
    */
   TypeProvider _typeProvider;
 
   /**
+   * The [TypeSystem] for this context, `null` if not yet created.
+   */
+  TypeSystem _typeSystem;
+
+  /**
    * The object used to manage the list of sources that need to be analyzed.
    */
   WorkManager _workManager = new WorkManager();
 
   /**
    * The [Stopwatch] of the current "perform tasks cycle".
    */
   Stopwatch _performAnalysisTaskStopwatch;
 
   /**
    * The controller for sending [SourcesChangedEvent]s.
    */
   StreamController<SourcesChangedEvent> _onSourcesChangedController;
 
   /**
+   * A subscription for a stream of events indicating when files are (and are
+   * not) being implicitly analyzed.
+   */
+  StreamController<ImplicitAnalysisEvent> _implicitAnalysisEventsController;
+
+  /**
    * The listeners that are to be notified when various analysis results are
    * produced in this context.
    */
   List<AnalysisListener> _listeners = new List<AnalysisListener>();
 
   /**
    * The most recently incrementally resolved source, or `null` when it was
    * already validated, or the most recent change was not incrementally resolved.
    */
   Source incrementalResolutionValidation_lastUnitSource;
@@ skipping 24 matching lines @@
   /**
    * A factory to override how [LibraryResolver] is created.
    */
   LibraryResolverFactory libraryResolverFactory;
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
-    _privatePartition = new UniversalCachePartition(this,
+    _privatePartition = new UniversalCachePartition(
+        this,
         AnalysisOptionsImpl.DEFAULT_CACHE_SIZE,
         new AnalysisContextImpl_ContextRetentionPolicy(this));
     _cache = createCacheFromSourceFactory(null);
     _onSourcesChangedController =
         new StreamController<SourcesChangedEvent>.broadcast();
+    _implicitAnalysisEventsController =
+        new StreamController<ImplicitAnalysisEvent>.broadcast();
   }
 
   @override
   AnalysisCache get analysisCache => _cache;
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         this._options.generateImplicitErrors !=
             options.generateImplicitErrors ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
         this._options.dart2jsHint != options.dart2jsHint ||
         (this._options.hint && !options.hint) ||
         this._options.preserveComments != options.preserveComments ||
-        this._options.enableStrictCallChecks != options.enableStrictCallChecks;
+        this._options.strongMode != options.strongMode ||
+        this._options.enableStrictCallChecks !=
+            options.enableStrictCallChecks ||
+        this._options.enableSuperMixins != options.enableSuperMixins;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
       //cache.setMaxCacheSize(cacheSize);
       _privatePartition.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.
       //
       // TODO(brianwilkerson) Remove this constraint when the new task model is
       // implemented.
       //
       int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
       if (_priorityOrder.length > maxPriorityOrderSize) {
         _priorityOrder = _priorityOrder.sublist(0, maxPriorityOrderSize);
       }
     }
     this._options.analyzeFunctionBodiesPredicate =
         options.analyzeFunctionBodiesPredicate;
     this._options.generateImplicitErrors = options.generateImplicitErrors;
     this._options.generateSdkErrors = options.generateSdkErrors;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.enableStrictCallChecks = options.enableStrictCallChecks;
+    this._options.enableSuperMixins = options.enableSuperMixins;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.incrementalApi = options.incrementalApi;
     this._options.incrementalValidation = options.incrementalValidation;
     this._options.lint = options.lint;
     this._options.preserveComments = options.preserveComments;
+    this._options.strongMode = options.strongMode;
     _generateImplicitErrors = options.generateImplicitErrors;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
       _invalidateAllLocalResolutionInformation(false);
     }
   }
 
   @override
   void set analysisPriorityOrder(List<Source> sources) {
     if (sources == null || sources.isEmpty) {
@@ skipping 44 matching lines @@
         targets.add(iterator.key);
       }
     }
     return targets;
   }
 
   @override
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   @override
+  Stream<ImplicitAnalysisEvent> get implicitAnalysisEvents =>
+      _implicitAnalysisEventsController.stream;
+
+  @override
   bool get isDisposed => _disposed;
 
   @override
   List<Source> get launchableClientLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that do not
     // reference dart:html, either directly or indirectly.
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
@@ skipping 293 matching lines @@
   }
 
   /**
    * Sets the [TypeProvider] for this context.
    */
   void set typeProvider(TypeProvider typeProvider) {
     _typeProvider = typeProvider;
   }
 
   @override
+  TypeSystem get typeSystem {
+    if (_typeSystem == null) {
+      _typeSystem = TypeSystem.create(this);
+    }
+    return _typeSystem;
+  }
+
+  @override
   void addListener(AnalysisListener listener) {
     if (!_listeners.contains(listener)) {
       _listeners.add(listener);
     }
   }
 
   @override
   void applyAnalysisDelta(AnalysisDelta delta) {
     ChangeSet changeSet = new ChangeSet();
     delta.analysisLevels.forEach((Source source, AnalysisLevel level) {
@@ skipping 53 matching lines @@
 
   @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
     }
     Source source = element.source;
     if (source == null) {
       return null;
     }
-    CompilationUnit unit = parseCompilationUnit(source);
-    if (unit == null) {
+    SourceRange docRange = element.docRange;
+    if (docRange == null) {
       return null;
     }
-    NodeLocator locator = new NodeLocator(element.nameOffset);
-    AstNode nameNode = locator.searchWithin(unit);
-    while (nameNode != null) {
-      if (nameNode is AnnotatedNode) {
-        Comment comment = nameNode.documentationComment;
-        if (comment == null) {
-          return null;
-        }
-        StringBuffer buffer = new StringBuffer();
-        List<Token> tokens = comment.tokens;
-        for (int i = 0; i < tokens.length; i++) {
-          if (i > 0) {
-            buffer.write("\n");
-          }
-          buffer.write(tokens[i].lexeme);
-        }
-        return buffer.toString();
-      }
-      nameNode = nameNode.parent;
-    }
-    return null;
+    String code = getContents(source).data;
+    String comment = code.substring(docRange.offset, docRange.end);
+    return comment.replaceAll('\r\n', '\n');
   }
 
   @override
   List<AnalysisError> computeErrors(Source source) {
     bool enableHints = _options.hint;
     bool enableLints = _options.lint;
 
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       List<AnalysisError> errors = new List<AnalysisError>();
       try {
         DartEntry dartEntry = sourceEntry;
         ListUtilities.addAll(
             errors, _getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
         dartEntry = _getReadableDartEntry(source);
         ListUtilities.addAll(errors,
             _getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS));
         dartEntry = _getReadableDartEntry(source);
         if (dartEntry.getValue(DartEntry.SOURCE_KIND) == SourceKind.LIBRARY) {
-          ListUtilities.addAll(errors, _getDartResolutionData(
-              source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
+          ListUtilities.addAll(
+              errors,
+              _getDartResolutionData(
+                  source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
           dartEntry = _getReadableDartEntry(source);
-          ListUtilities.addAll(errors, _getDartVerificationData(
-              source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
+          ListUtilities.addAll(
+              errors,
+              _getDartVerificationData(
+                  source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
           if (enableHints) {
             dartEntry = _getReadableDartEntry(source);
             ListUtilities.addAll(errors,
                 _getDartHintData(source, source, dartEntry, DartEntry.HINTS));
           }
           if (enableLints) {
             dartEntry = _getReadableDartEntry(source);
             ListUtilities.addAll(errors,
                 _getDartLintData(source, source, dartEntry, DartEntry.LINTS));
           }
         } else {
           List<Source> libraries = getLibrariesContaining(source);
           for (Source librarySource in libraries) {
-            ListUtilities.addAll(errors, _getDartResolutionData(
-                source, librarySource, dartEntry, DartEntry.RESOLUTION_ERRORS));
+            ListUtilities.addAll(
+                errors,
+                _getDartResolutionData(source, librarySource, dartEntry,
+                    DartEntry.RESOLUTION_ERRORS));
             dartEntry = _getReadableDartEntry(source);
-            ListUtilities.addAll(errors, _getDartVerificationData(source,
-                librarySource, dartEntry, DartEntry.VERIFICATION_ERRORS));
+            ListUtilities.addAll(
+                errors,
+                _getDartVerificationData(source, librarySource, dartEntry,
+                    DartEntry.VERIFICATION_ERRORS));
             if (enableHints) {
               dartEntry = _getReadableDartEntry(source);
-              ListUtilities.addAll(errors, _getDartHintData(
-                  source, librarySource, dartEntry, DartEntry.HINTS));
+              ListUtilities.addAll(
+                  errors,
+                  _getDartHintData(
+                      source, librarySource, dartEntry, DartEntry.HINTS));
             }
             if (enableLints) {
               dartEntry = _getReadableDartEntry(source);
-              ListUtilities.addAll(errors, _getDartLintData(
-                  source, librarySource, dartEntry, DartEntry.LINTS));
+              ListUtilities.addAll(
+                  errors,
+                  _getDartLintData(
+                      source, librarySource, dartEntry, DartEntry.LINTS));
             }
           }
         }
       } on ObsoleteSourceAnalysisException catch (exception, stackTrace) {
         AnalysisEngine.instance.logger.logInformation(
             "Could not compute errors",
             new CaughtException(exception, stackTrace));
       }
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
@@ skipping 75 matching lines @@
       throw new AnalysisException(
           "Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}",
           new CaughtException(dartEntry.exception, null));
     }
     return unit;
   }
 
   @override
   CancelableFuture<CompilationUnit> computeResolvedCompilationUnitAsync(
       Source unitSource, Source librarySource) {
-    return new _AnalysisFutureHelper<CompilationUnit>(this).computeAsync(
-        unitSource, (SourceEntry sourceEntry) {
+    return new _AnalysisFutureHelper<CompilationUnit>(this)
+        .computeAsync(unitSource, (SourceEntry sourceEntry) {
       if (sourceEntry is DartEntry) {
         if (sourceEntry.getStateInLibrary(
                 DartEntry.RESOLVED_UNIT, librarySource) ==
             CacheState.ERROR) {
           throw sourceEntry.exception;
         }
         return sourceEntry.getValueInLibrary(
             DartEntry.RESOLVED_UNIT, librarySource);
       }
       throw new AnalysisNotScheduledError();
     });
   }
 
+  @override
+  Object computeResult(AnalysisTarget target, ResultDescriptor result) {
+    return result.defaultValue;
+  }
+
   /**
    * Create an analysis cache based on the given source [factory].
    */
   AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
       return new AnalysisCache(<CachePartition>[_privatePartition]);
     }
     DartSdk sdk = factory.dartSdk;
     if (sdk == null) {
       return new AnalysisCache(<CachePartition>[_privatePartition]);
@@ skipping 307 matching lines @@
     Namespace namespace = null;
     if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
       namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
     }
     if (namespace == null) {
       NamespaceBuilder builder = new NamespaceBuilder();
       namespace = builder.createPublicNamespaceForLibrary(library);
       if (dartEntry == null) {
         AnalysisEngine.instance.logger.logError(
             "Could not compute the public namespace for ${library.source.fullName}",
-            new CaughtException(new AnalysisException(
+            new CaughtException(
+                new AnalysisException(
                     "A Dart file became a non-Dart file: ${source.fullName}"),
                 null));
         return null;
       }
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
         dartEntry.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
       }
     }
     return namespace;
   }
@@ skipping 29 matching lines @@
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
   @override
+  Object getResult(AnalysisTarget target, ResultDescriptor result) {
+    return result.defaultValue;
+  }
+
+  @override
   List<Source> getSourcesWithFullName(String path) {
     List<Source> sources = <Source>[];
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.key.fullName == path) {
         sources.add(iterator.key);
       }
     }
     return sources;
   }
@@ skipping 125 matching lines @@
     }
     return PerformanceStatistics.performAnaysis.makeCurrentWhile(() {
       int getStart = JavaSystem.currentTimeMillis();
       AnalysisTask task = PerformanceStatistics.nextTask
           .makeCurrentWhile(() => nextAnalysisTask);
       int getEnd = JavaSystem.currentTimeMillis();
       if (task == null) {
         _validateLastIncrementalResolutionResult();
         if (_performAnalysisTaskStopwatch != null) {
           AnalysisEngine.instance.instrumentationService.logPerformance(
-              AnalysisPerformanceKind.FULL, _performAnalysisTaskStopwatch,
+              AnalysisPerformanceKind.FULL,
+              _performAnalysisTaskStopwatch,
               'context_id=$_id');
           _performAnalysisTaskStopwatch = null;
         }
         return new AnalysisResult(
             _getChangeNotices(true), getEnd - getStart, null, -1);
       }
       if (_performAnalysisTaskStopwatch == null) {
         _performAnalysisTaskStopwatch = new Stopwatch()..start();
       }
       String taskDescription = task.toString();
@@ skipping 97 matching lines @@
         // during resolution.
         //
         if (thrownException == null) {
           var message = "In recordResolveDartLibraryCycleTaskResults, "
               "resolvedLibraries was null and there was no thrown exception";
           unitEntry.recordResolutionError(
               new CaughtException(new AnalysisException(message), null));
         } else {
           unitEntry.recordResolutionError(thrownException);
         }
-        _cache.remove(unitSource);
+        _removeFromCache(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
         return unitEntry;
       }
       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) {
@@ skipping 52 matching lines @@
         // during resolution.
         //
         if (thrownException == null) {
           String message = "In recordResolveDartLibraryTaskResults, "
               "resolvedLibraries was null and there was no thrown exception";
           unitEntry.recordResolutionError(
               new CaughtException(new AnalysisException(message), null));
         } else {
           unitEntry.recordResolutionError(thrownException);
         }
-        _cache.remove(unitSource);
+        _removeFromCache(unitSource);
         if (thrownException != null) {
           throw new AnalysisException('<rethrow>', thrownException);
         }
         return unitEntry;
       }
       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);
           if (thrownException == null) {
             dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
             dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
             dartEntry.setValueInLibrary(
                 DartEntry.RESOLVED_UNIT, librarySource, unit);
             dartEntry.setValueInLibrary(
                 DartEntry.RESOLUTION_ERRORS, librarySource, errors);
             if (source == librarySource) {
               _recordElementData(
                   dartEntry, library.libraryElement, librarySource, htmlSource);
             }
             _cache.storedAst(source);
           } else {
             dartEntry.recordResolutionErrorInLibrary(
                 librarySource, thrownException);
-            _cache.remove(source);
+            _removeFromCache(source);
           }
           if (source != librarySource) {
             _workManager.add(source, SourcePriority.PRIORITY_PART);
           }
           ChangeNoticeImpl notice = getNotice(source);
           notice.resolvedDartUnit = unit;
           notice.setErrors(dartEntry.allErrors, lineInfo);
         }
       }
     }
@@ skipping 12 matching lines @@
   CompilationUnit resolveCompilationUnit(
       Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
   @override
   CompilationUnit resolveCompilationUnit2(
-      Source unitSource, Source librarySource) => _getDartResolutionData2(
+          Source unitSource, Source librarySource) =>
+      _getDartResolutionData2(
           unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
   @override
   @deprecated
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   @override
@@ skipping 48 matching lines @@
       }
     }
     int count = changedSources.length;
     for (int i = 0; i < count; i++) {
       _sourceChanged(changedSources[i]);
     }
     int removalCount = 0;
     for (Source source in missingSources) {
       if (getLibrariesContaining(source).isEmpty &&
           getLibrariesDependingOn(source).isEmpty) {
-        _cache.remove(source);
+        _removeFromCache(source);
         removalCount++;
       }
     }
     int consistencyCheckEnd = JavaSystem.nanoTime();
     if (changedSources.length > 0 || missingSources.length > 0) {
       StringBuffer buffer = new StringBuffer();
       buffer.write("Consistency check took ");
       buffer.write((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
       buffer.writeln(" ms and found");
       buffer.write("  ");
@@ skipping 234 matching lines @@
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     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 = _cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
-      dartEntry = new ParseDartTask(this, source,
+      dartEntry = new ParseDartTask(
+              this,
+              source,
               dartEntry.getValue(DartEntry.TOKEN_STREAM),
               dartEntry.getValue(SourceEntry.LINE_INFO))
           .perform(_resultRecorder) as DartEntry;
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a
@@ skipping 43 matching lines @@
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     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.
       //
       try {
         if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
-          dartEntry = new GetContentTask(this, source)
-              .perform(_resultRecorder) as DartEntry;
+          dartEntry = new GetContentTask(this, source).perform(_resultRecorder)
+              as DartEntry;
         }
         dartEntry = new ScanDartTask(
                 this, source, dartEntry.getValue(SourceEntry.CONTENT))
             .perform(_resultRecorder) as DartEntry;
       } on AnalysisException catch (exception) {
         throw exception;
       } catch (exception, stackTrace) {
         throw new AnalysisException(
             "Exception", new CaughtException(exception, stackTrace));
       }
@@ skipping 55 matching lines @@
     // Check to see whether we already have the information being requested.
     //
     CacheState state = htmlEntry.getState(descriptor);
     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.
       //
       try {
         if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
-          htmlEntry = new GetContentTask(this, source)
-              .perform(_resultRecorder) as HtmlEntry;
+          htmlEntry = new GetContentTask(this, source).perform(_resultRecorder)
+              as HtmlEntry;
         }
         htmlEntry = new ParseHtmlTask(
                 this, source, htmlEntry.getValue(SourceEntry.CONTENT))
             .perform(_resultRecorder) as HtmlEntry;
       } on AnalysisException catch (exception) {
         throw exception;
       } catch (exception, stackTrace) {
         throw new AnalysisException(
             "Exception", new CaughtException(exception, stackTrace));
       }
@@ skipping 115 matching lines @@
    * event where as this method does not.
    */
   bool _contentRangeChanged(Source source, String contents, int offset,
       int oldLength, int newLength) {
     bool changed = false;
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         if (_options.incremental) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.update(
-              _incrementalAnalysisCache, source, originalContents, contents,
-              offset, oldLength, newLength, _getReadableSourceEntry(source));
+              _incrementalAnalysisCache,
+              source,
+              originalContents,
+              contents,
+              offset,
+              oldLength,
+              newLength,
+              _getReadableSourceEntry(source));
         }
         _sourceChanged(source);
         changed = true;
         SourceEntry sourceEntry = _cache.get(source);
         if (sourceEntry != null) {
           sourceEntry.modificationTime =
               _contentCache.getModificationStamp(source);
           sourceEntry.setValue(SourceEntry.CONTENT, contents);
         }
       }
@@ skipping 27 matching lines @@
   AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source unitSource,
       DartEntry unitEntry, Source librarySource, DartEntry libraryEntry) {
     if (unitEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) !=
             CacheState.VALID ||
         libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     CompilationUnit unit =
         unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     if (unit == null) {
-      CaughtException exception = new CaughtException(new AnalysisException(
+      CaughtException exception = new CaughtException(
+          new AnalysisException(
               "Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}"),
           null);
-      AnalysisEngine.instance.logger.logInformation(
-          exception.toString(), exception);
+      AnalysisEngine.instance.logger
+          .logInformation(exception.toString(), exception);
       unitEntry.recordResolutionError(exception);
       return new AnalysisContextImpl_TaskData(null, false);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     return new AnalysisContextImpl_TaskData(
         new GenerateDartErrorsTask(this, unitSource, unit, libraryElement),
         false);
   }
 
   /**
@@ skipping 77 matching lines @@
    * Create a [ParseDartTask] for the given [source].
    */
   AnalysisContextImpl_TaskData _createParseDartTask(
       Source source, DartEntry dartEntry) {
     if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID ||
         dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
     dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
-    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source,
-        tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
+    return new AnalysisContextImpl_TaskData(
+        new ParseDartTask(this, source, tokenStream,
+            dartEntry.getValue(SourceEntry.LINE_INFO)),
+        false);
   }
 
   /**
    * Create a [ParseHtmlTask] for the given [source].
    */
   AnalysisContextImpl_TaskData _createParseHtmlTask(
       Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, htmlEntry);
     }
@@ skipping 12 matching lines @@
     try {
       AnalysisContextImpl_CycleBuilder builder =
           new AnalysisContextImpl_CycleBuilder(this);
       PerformanceStatistics.cycles.makeCurrentWhile(() {
         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);
+      return new AnalysisContextImpl_TaskData(
+          new ResolveDartLibraryCycleTask(
+              this, source, source, builder.librariesInCycle),
+          false);
     } on AnalysisException catch (exception, stackTrace) {
       dartEntry
           .recordResolutionError(new CaughtException(exception, stackTrace));
       AnalysisEngine.instance.logger.logError(
           "Internal error trying to create a ResolveDartLibraryTask",
           new CaughtException(exception, stackTrace));
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Create a [ResolveHtmlTask] for the given [source], marking the resolved
    * unit as being in-process.
    */
   AnalysisContextImpl_TaskData _createResolveHtmlTask(
       Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
       return _createParseHtmlTask(source, htmlEntry);
     }
-    return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source,
-        htmlEntry.modificationTime,
-        htmlEntry.getValue(HtmlEntry.PARSED_UNIT)), false);
+    return new AnalysisContextImpl_TaskData(
+        new ResolveHtmlTask(this, source, htmlEntry.modificationTime,
+            htmlEntry.getValue(HtmlEntry.PARSED_UNIT)),
+        false);
   }
 
   /**
    * Create a [ScanDartTask] for the given [source], marking the scan errors as
    * being in-process.
    */
   AnalysisContextImpl_TaskData _createScanDartTask(
       Source source, DartEntry dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
     dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     return new AnalysisContextImpl_TaskData(
         new ScanDartTask(this, source, content), false);
   }
 
   /**
    * Create a source entry for the given [source]. Return the source entry that
    * was created, or `null` if the source should not be tracked by this context.
    */
   SourceEntry _createSourceEntry(Source source, bool explicitlyAdded) {
     String name = source.shortName;
     if (AnalysisEngine.isHtmlFileName(name)) {
       HtmlEntry htmlEntry = new HtmlEntry();
       htmlEntry.modificationTime = getModificationStamp(source);
       htmlEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, htmlEntry);
+      if (!explicitlyAdded) {
+        _implicitAnalysisEventsController
+            .add(new ImplicitAnalysisEvent(source, true));
+      }
       return htmlEntry;
     } else {
       DartEntry dartEntry = new DartEntry();
       dartEntry.modificationTime = getModificationStamp(source);
       dartEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, dartEntry);
+      if (!explicitlyAdded) {
+        _implicitAnalysisEventsController
+            .add(new ImplicitAnalysisEvent(source, true));
+      }
       return dartEntry;
     }
   }
 
   /**
    * Return a list containing all of the change notices that are waiting to be
    * returned. If there are no notices, then return either `null` or an empty
    * list, depending on the value of [nullIfEmpty].
    */
   List<ChangeNotice> _getChangeNotices(bool nullIfEmpty) {
@@ skipping 281 matching lines @@
       _accessedAst(source);
     }
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * 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.
    */
-  AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source,
-      SourceEntry sourceEntry, bool isPriority, bool hintsEnabled,
+  AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(
+      Source source,
+      SourceEntry sourceEntry,
+      bool isPriority,
+      bool hintsEnabled,
       bool lintsEnabled) {
     // Refuse to generate tasks for html based files that are above 1500 KB
     if (_isTooBigHtmlSourceEntry(source, sourceEntry)) {
       // TODO (jwren) we still need to report an error of some kind back to the
       // client.
       return new AnalysisContextImpl_TaskData(null, false);
     }
     if (sourceEntry == null) {
       return new AnalysisContextImpl_TaskData(null, false);
     }
@@ skipping 169 matching lines @@
    * the library defined by the given [librarySource], or `null` if the
    * information is not cached.
    */
   TimestampedData<CompilationUnit> _getResolvedUnit(
       CompilationUnitElement element, Source librarySource) {
     SourceEntry sourceEntry = _cache.get(element.source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) ==
           CacheState.VALID) {
-        return new TimestampedData<CompilationUnit>(dartEntry.modificationTime,
+        return new TimestampedData<CompilationUnit>(
+            dartEntry.modificationTime,
             dartEntry.getValueInLibrary(
                 DartEntry.RESOLVED_UNIT, librarySource));
       }
     }
     return null;
   }
 
   /**
    * Return a list containing all of the sources known to this context that have
    * the given [kind].
    */
   List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.value.kind == kind) {
         sources.add(iterator.key);
       }
     }
     return sources;
   }
 
   /**
    * Look at the given [source] to see whether a task needs to be performed
    * related to it. If so, add the source to the set of sources that need to be
    * processed. This method duplicates, and must therefore be kept in sync with,
    * [_getNextAnalysisTaskForSource]. This method is intended to be used for
    * testing purposes only.
    */
-  void _getSourcesNeedingProcessing(Source source, SourceEntry sourceEntry,
-      bool isPriority, bool hintsEnabled, bool lintsEnabled,
+  void _getSourcesNeedingProcessing(
+      Source source,
+      SourceEntry sourceEntry,
+      bool isPriority,
+      bool hintsEnabled,
+      bool lintsEnabled,
       HashSet<Source> sources) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
       if (scanErrorsState == CacheState.INVALID ||
           (isPriority && scanErrorsState == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
@@ skipping 166 matching lines @@
       if (_isClient(exported, htmlSource, visitedLibraries)) {
         return true;
       }
     }
     return false;
   }
 
   bool _isTooBigHtmlSourceEntry(Source source, SourceEntry sourceEntry) =>
       false;
 
-  /**
-   * Log the given debugging [message].
-   */
-  void _logInformation(String message) {
-    AnalysisEngine.instance.logger.logInformation(message);
-  }
-
 //  /**
 //   * Notify all of the analysis listeners that the given source is no longer included in the set of
 //   * sources that are being analyzed.
 //   *
 //   * @param source the source that is no longer being analyzed
 //   */
 //  void _notifyExcludedSource(Source source) {
 //    int count = _listeners.length;
 //    for (int i = 0; i < count; i++) {
 //      _listeners[i].excludedSource(this, source);
@@ skipping 59 matching lines @@
 //   * @param unit the result of resolving the source
 //   */
 //  void _notifyResolvedHtml(Source source, ht.HtmlUnit unit) {
 //    int count = _listeners.length;
 //    for (int i = 0; i < count; i++) {
 //      _listeners[i].resolvedHtml(this, source, unit);
 //    }
 //  }
 
   /**
+   * Log the given debugging [message].
+   */
+  void _logInformation(String message) {
+    AnalysisEngine.instance.logger.logInformation(message);
+  }
+
+  /**
    * Notify all of the analysis listeners that a task is about to be performed.
    */
   void _notifyAboutToPerformTask(String taskDescription) {
     int count = _listeners.length;
     for (int i = 0; i < count; i++) {
       _listeners[i].aboutToPerformTask(this, taskDescription);
     }
   }
 
   /**
@@ skipping 362 matching lines @@
     LineInfo lineInfo = task.lineInfo;
     dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo);
     dartEntry.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
     dartEntry.setValue(DartEntry.SCAN_ERRORS, task.errors);
     _cache.storedAst(source);
     ChangeNoticeImpl notice = getNotice(source);
     notice.setErrors(dartEntry.allErrors, lineInfo);
     return dartEntry;
   }
 
+  void _removeFromCache(Source source) {
+    SourceEntry entry = _cache.remove(source);
+    if (entry != null && !entry.explicitlyAdded) {
+      _implicitAnalysisEventsController
+          .add(new ImplicitAnalysisEvent(source, false));
+    }
+  }
+
   /**
    * Remove the given [librarySource] from the list of containing libraries for
    * all of the parts referenced by the given [dartEntry].
    */
   void _removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
       DartEntry partEntry = _getReadableDartEntry(partSource);
       if (partEntry != null && !identical(partEntry, dartEntry)) {
         partEntry.removeContainingLibrary(librarySource);
         if (partEntry.containingLibraries.length == 0 && !exists(partSource)) {
-          _cache.remove(partSource);
+          _removeFromCache(partSource);
         }
       }
     }
   }
 
   /**
    * Remove the given libraries that are keys in the given map from the list of
    * containing libraries for each of the parts in the corresponding value.
    */
   void _removeFromPartsUsingMap(HashMap<Source, List<Source>> oldPartMap) {
     oldPartMap.forEach((Source librarySource, List<Source> oldParts) {
       for (int i = 0; i < oldParts.length; i++) {
         Source partSource = oldParts[i];
         if (partSource != librarySource) {
           DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null) {
             partEntry.removeContainingLibrary(librarySource);
             if (partEntry.containingLibraries.length == 0 &&
                 !exists(partSource)) {
-              _cache.remove(partSource);
+              _removeFromCache(partSource);
             }
           }
         }
       }
     });
   }
 
   /**
    * Remove the given [source] from the priority order if it is in the list.
    */
   void _removeFromPriorityOrder(Source source) {
     int count = _priorityOrder.length;
     List<Source> newOrder = new List<Source>();
     for (int i = 0; i < count; i++) {
       if (_priorityOrder[i] != source) {
         newOrder.add(_priorityOrder[i]);
       }
     }
     if (newOrder.length < count) {
       analysisPriorityOrder = newOrder;
     }
   }
 
   /**
    * Create an entry for the newly added [source] and invalidate any sources
    * that referenced the source before it existed.
    */
   void _sourceAvailable(Source source) {
+    // TODO(brianwilkerson) This method needs to check whether the source was
+    // previously being implicitly analyzed. If so, the cache entry needs to be
+    // update to reflect the new status and an event needs to be generated to
+    // inform clients that it is no longer being implicitly analyzed.
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       sourceEntry = _createSourceEntry(source, true);
     } else {
       _propagateInvalidation(source, sourceEntry);
       sourceEntry = _cache.get(source);
     }
     if (sourceEntry is HtmlEntry) {
       _workManager.add(source, SourcePriority.HTML);
     } else if (sourceEntry is DartEntry) {
@@ skipping 68 matching lines @@
         libraries.add(librarySource);
         for (Source dependentLibrary
             in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         _invalidateLibraryResolution(librarySource);
       }
     }
-    _cache.remove(source);
+    _removeFromCache(source);
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * TODO(scheglov) A hackish, limited incremental resolution implementation.
    */
   bool _tryPoorMansIncrementalResolution(Source unitSource, String newCode) {
     return PerformanceStatistics.incrementalAnalysis.makeCurrentWhile(() {
       incrementalResolutionValidation_lastUnitSource = null;
@@ skipping 17 matching lines @@
       }
       // prepare the existing unit
       CompilationUnit oldUnit =
           getResolvedCompilationUnit2(unitSource, librarySource);
       if (oldUnit == null) {
         return false;
       }
       // do resolution
       Stopwatch perfCounter = new Stopwatch()..start();
       PoorMansIncrementalResolver resolver = new PoorMansIncrementalResolver(
-          typeProvider, unitSource, getReadableSourceEntryOrNull(unitSource),
-          null, null, oldUnit, analysisOptions.incrementalApi, analysisOptions);
+          typeProvider,
+          unitSource,
+          getReadableSourceEntryOrNull(unitSource),
+          null,
+          null,
+          oldUnit,
+          analysisOptions.incrementalApi);
       bool success = resolver.resolve(newCode);
       AnalysisEngine.instance.instrumentationService.logPerformance(
-          AnalysisPerformanceKind.INCREMENTAL, perfCounter,
+          AnalysisPerformanceKind.INCREMENTAL,
+          perfCounter,
           'success=$success,context_id=$_id,code_length=${newCode.length}');
       if (!success) {
         return false;
       }
       // if validation, remember the result, but throw it away
       if (analysisOptions.incrementalValidation) {
         incrementalResolutionValidation_lastUnitSource = oldUnit.element.source;
         incrementalResolutionValidation_lastLibrarySource =
             oldUnit.element.library.source;
         incrementalResolutionValidation_lastUnit = oldUnit;
@@ skipping 199 matching lines @@
     _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);
+        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
@@ skipping 207 matching lines @@
    * Ensure that the given [library] has an element model built for it. If
    * another task needs to be executed first in order to build the element
    * model, that task is placed in [taskData].
    */
   void _ensureElementModel(ResolvableLibrary library) {
     Source librarySource = library.librarySource;
     DartEntry libraryEntry =
         AnalysisContextImpl_this._getReadableDartEntry(librarySource);
     if (libraryEntry != null &&
         libraryEntry.getState(DartEntry.PARSED_UNIT) != CacheState.ERROR) {
-      AnalysisContextImpl_this._workManager.addFirst(
-          librarySource, SourcePriority.LIBRARY);
+      AnalysisContextImpl_this._workManager
+          .addFirst(librarySource, SourcePriority.LIBRARY);
       if (_taskData == null) {
         _taskData = AnalysisContextImpl_this._createResolveDartLibraryTask(
             librarySource, libraryEntry);
       }
     }
   }
 
   /**
    * 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.
@@ skipping 561 matching lines @@
    */
   bool useTaskModel = false;
 
   /**
    * A flag indicating whether the task model should attempt to limit
    * invalidation after a change.
    */
   bool limitInvalidationInTaskModel = false;
 
   /**
+   * The plugins that are defined outside the `analyzer` package.
+   */
+  List<Plugin> _userDefinedPlugins = <Plugin>[];
+
+  /**
    * The task manager used to manage the tasks used to analyze code.
    */
   TaskManager _taskManager;
 
   AnalysisEngine._();
 
   /**
    * Return the instrumentation service that is to be used by this analysis
    * engine.
    */
@@ skipping 28 matching lines @@
   /**
    * Return the list of supported plugins for processing by clients.
    */
   List<Plugin> get supportedPlugins {
     if (_supportedPlugins == null) {
       _supportedPlugins = <Plugin>[
         enginePlugin,
         commandLinePlugin,
         optionsPlugin
       ];
+      _supportedPlugins.addAll(_userDefinedPlugins);
     }
     return _supportedPlugins;
   }
 
   /**
    * Return the task manager used to manage the tasks used to analyze code.
    */
   TaskManager get taskManager {
     if (_taskManager == null) {
-      if (enginePlugin.taskExtensionPoint == null) {
-        // The plugin wasn't used, so tasks are not registered.
-        new ExtensionManager().processPlugins([enginePlugin]);
-      }
+      new ExtensionManager().processPlugins(supportedPlugins);
       _taskManager = new TaskManager();
       _taskManager.addTaskDescriptors(enginePlugin.taskDescriptors);
       // TODO(brianwilkerson) Create a way to associate different results with
       // different file suffixes, then make this pluggable.
       _taskManager.addGeneralResult(DART_ERRORS);
     }
     return _taskManager;
   }
 
   /**
+   * Set plugins that are defined outside the `analyzer` package.
+   */
+  void set userDefinedPlugins(List<Plugin> plugins) {
+    if (plugins == null) {
+      plugins = <Plugin>[];
+    }
+    _userDefinedPlugins = plugins;
+    _supportedPlugins = null;
+    _taskManager = null;
+  }
+
+  /**
    * Clear any caches holding on to analysis results so that a full re-analysis
    * will be performed the next time an analysis context is created.
    */
   void clearCaches() {
     partitionManager.clearCache();
   }
 
   /**
    * Create and return a new context in which analysis can be performed.
    */
@@ skipping 226 matching lines @@
   @deprecated // Always true
   bool get enableNullAwareOperators;
 
   /**
    * Return `true` to strictly follow the specification when generating
    * warnings on "call" methods (fixes dartbug.com/21938).
    */
   bool get enableStrictCallChecks;
 
   /**
+   * Return `true` if mixins are allowed to inherit from types other than
+   * Object, and are allowed to reference `super`.
+   */
+  bool get enableSuperMixins;
+
+  /**
    * Return `true` if errors, warnings and hints should be generated for sources
    * that are implicitly being analyzed. The default value is `true`.
    */
   bool get generateImplicitErrors;
 
   /**
    * Return `true` if errors, warnings and hints should be generated for sources
    * in the SDK. The default value is `false`.
    */
   bool get generateSdkErrors;
@@ skipping 23 matching lines @@
 
   /**
    * Return `true` if analysis is to generate lint warnings.
    */
   bool get lint;
 
   /**
    * Return `true` if analysis is to parse comments.
    */
   bool get preserveComments;
+
+  /**
+   * Return `true` if strong mode analysis should be used.
+   */
+  bool get strongMode;
 }
 
 /**
  * A set of analysis options used to control the behavior of an analysis
  * context.
  */
 class AnalysisOptionsImpl implements AnalysisOptions {
   /**
    * The maximum number of sources for which data should be kept in the cache.
    */
@@ skipping 21 matching lines @@
   /**
    * The maximum number of sources for which AST structures should be kept in
    * the cache.
    */
   int cacheSize = DEFAULT_CACHE_SIZE;
 
   /**
    * A flag indicating whether analysis is to generate dart2js related hint
    * results.
    */
-  bool dart2jsHint = true;
+  bool dart2jsHint = false;
 
   /**
    * A flag indicating whether generic methods are to be supported (DEP 22).
    */
   bool enableGenericMethods = false;
 
   /**
    * A flag indicating whether analysis is to strictly follow the specification
    * when generating warnings on "call" methods (fixes dartbug.com/21938).
    */
   bool enableStrictCallChecks = false;
 
   /**
+   * A flag indicating whether mixins are allowed to inherit from types other
+   * than Object, and are allowed to reference `super`.
+   */
+  bool enableSuperMixins = false;
+
+  /**
    * A flag indicating whether errors, warnings and hints should be generated
    * for sources that are implicitly being analyzed.
    */
   bool generateImplicitErrors = true;
 
   /**
    * A flag indicating whether errors, warnings and hints should be generated
    * for sources in the SDK.
    */
   bool generateSdkErrors = false;
@@ skipping 25 matching lines @@
    * A flag indicating whether analysis is to generate lint warnings.
    */
   bool lint = false;
 
   /**
    * A flag indicating whether analysis is to parse comments.
    */
   bool preserveComments = true;
 
   /**
+   * A flag indicating whether strong-mode analysis should be used.
+   */
+  bool strongMode = false;
+
+  /**
    * Initialize a newly created set of analysis options to have their default
    * values.
    */
   AnalysisOptionsImpl();
 
   /**
    * Initialize a newly created set of analysis options to have the same values
    * as those in the given set of analysis [options].
    */
   @deprecated // Use new AnalysisOptionsImpl.from(options)
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
     enableStrictCallChecks = options.enableStrictCallChecks;
+    enableSuperMixins = options.enableSuperMixins;
     generateImplicitErrors = options.generateImplicitErrors;
     generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
     preserveComments = options.preserveComments;
+    strongMode = options.strongMode;
   }
 
   /**
    * Initialize a newly created set of analysis options to have the same values
    * as those in the given set of analysis [options].
    */
   AnalysisOptionsImpl.from(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
     enableStrictCallChecks = options.enableStrictCallChecks;
+    enableSuperMixins = options.enableSuperMixins;
     generateImplicitErrors = options.generateImplicitErrors;
     generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
     preserveComments = options.preserveComments;
+    strongMode = options.strongMode;
   }
 
   bool get analyzeFunctionBodies {
     if (identical(analyzeFunctionBodiesPredicate, _analyzeAllFunctionBodies)) {
       return true;
     } else if (identical(
         analyzeFunctionBodiesPredicate, _analyzeNoFunctionBodies)) {
       return false;
     } else {
       throw new StateError('analyzeFunctionBodiesPredicate in use');
@@ skipping 187 matching lines @@
    * Perform this analysis task, ensuring that all exceptions are wrapped in an
    * [AnalysisException]. Throws an [AnalysisException] if any exception occurs
    * while performing the task
    */
   void _safelyPerform() {
     try {
       String contextName = context.name;
       if (contextName == null) {
         contextName = 'unnamed';
       }
-      AnalysisEngine.instance.instrumentationService.logAnalysisTask(
-          contextName, taskDescription);
+      AnalysisEngine.instance.instrumentationService
+          .logAnalysisTask(contextName, taskDescription);
       internalPerform();
     } on AnalysisException {
       rethrow;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           exception.toString(), new CaughtException(exception, stackTrace));
     }
   }
 }
 
@@ skipping 137 matching lines @@
    * it's cached AST structure flushed.
    */
   List<Source> _recentlyUsed;
 
   /**
    * Initialize a newly created cache to maintain at most [maxCacheSize] AST
    * structures in the cache. The cache is owned by the give [context], and the
    * [retentionPolicy] will be used to determine which pieces of data to remove
    * from the cache.
    */
-  CachePartition(this.context, int maxCacheSize, this._retentionPolicy) {
-    this._maxCacheSize = maxCacheSize;
+  CachePartition(this.context, this._maxCacheSize, this._retentionPolicy) {
     _recentlyUsed = new List<Source>();
   }
 
   /**
    * Return the number of entries in this partition that have an AST associated
    * with them.
    */
   int get astSize {
     int astSize = 0;
     int count = _recentlyUsed.length;
@@ skipping 70 matching lines @@
 
   /**
    * Associate the given [entry] with the given [source].
    */
   void put(Source source, SourceEntry entry) {
     entry.fixExceptionState();
     _sourceMap[source] = entry;
   }
 
   /**
-   * Remove all information related to the given [source] from this cache.
+   * Remove all information related to the given [source] from this partition.
+   * Return the entry associated with the source, or `null` if there was cache
+   * entry for the source.
    */
-  void remove(Source source) {
+  SourceEntry remove(Source source) {
     _recentlyUsed.remove(source);
-    _sourceMap.remove(source);
+    return _sourceMap.remove(source);
   }
 
   /**
    * Record that the AST associated with the given [source] was just removed
    * from the cache.
    */
   void removedAst(Source source) {
     _recentlyUsed.remove(source);
   }
 
@@ skipping 539 matching lines @@
 
   /**
    * The (source, entry) pairs representing the compilation units in the
    * library.
    */
   List<CycleBuilder_SourceEntryPair> entryPairs;
 
   /**
    * Initialize a newly created pair from the given [library] and [entryPairs].
    */
-  CycleBuilder_LibraryPair(ResolvableLibrary library,
-      List<CycleBuilder_SourceEntryPair> entryPairs) {
-    this.library = library;
-    this.entryPairs = entryPairs;
-  }
+  CycleBuilder_LibraryPair(this.library, this.entryPairs);
 }
 
 /**
  * A pair containing 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 from the given [source] and [entry].
    */
-  CycleBuilder_SourceEntryPair(Source source, DartEntry entry) {
-    this.source = source;
-    this.entry = entry;
-  }
+  CycleBuilder_SourceEntryPair(this.source, this.entry);
 }
 
 /**
  * The information cached by an analysis context about an individual Dart file.
  */
 class DartEntry extends SourceEntry {
   /**
    * The data descriptor representing the element model representing a single
    * compilation unit. This model is incomplete and should not be used except as
    * input to another task.
@@ skipping 976 matching lines @@
       //
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, libraryElement, typeProvider);
 //      _unit.accept(constantVerifier);
       //
       // Use the ErrorVerifier to compute the rest of the errors.
       //
-      ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter,
-          libraryElement, typeProvider, new InheritanceManager(libraryElement));
+      ErrorVerifier errorVerifier = new ErrorVerifier(
+          errorReporter,
+          libraryElement,
+          typeProvider,
+          new InheritanceManager(libraryElement),
+          context.analysisOptions.enableSuperMixins);
       _unit.accept(errorVerifier);
       _errors = errorListener.getErrorsForSource(source);
     });
   }
 
   /**
    * Check each directive in the given compilation unit to see if the referenced source exists and
    * report an error if it does not.
    *
    * @param context the context in which the library exists
@@ skipping 13 matching lines @@
 
   /**
    * Check the given directive to see if the referenced source exists and report an error if it does
    * not.
    *
    * @param context the context in which the library exists
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive to be verified
    * @param errorListener the error listener to which errors should be reported
    */
-  static void validateReferencedSource(AnalysisContext context,
-      Source librarySource, UriBasedDirective directive,
+  static void validateReferencedSource(
+      AnalysisContext context,
+      Source librarySource,
+      UriBasedDirective directive,
       AnalysisErrorListener errorListener) {
     Source source = directive.source;
     if (source != null) {
       if (context.exists(source)) {
         return;
       }
     } else {
       // Don't report errors already reported by ParseDartTask.resolveDirective
       if (directive.validate() != null) {
         return;
       }
     }
     StringLiteral uriLiteral = directive.uri;
-    errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
-        uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST,
+    errorListener.onError(new AnalysisError(
+        librarySource,
+        uriLiteral.offset,
+        uriLiteral.length,
+        CompileTimeErrorCode.URI_DOES_NOT_EXIST,
         [directive.uriContent]));
   }
 }
 
 /**
  * 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
@@ skipping 71 matching lines @@
     _hintMap = new HashMap<Source, List<AnalysisError>>();
     for (int i = 0; i < unitCount; i++) {
       Source source = _units[i].data.element.source;
       _hintMap[source] = errorListener.getErrorsForSource(source);
     }
   }
 }
 
 /// Generates lint feedback for a single Dart library.
 class GenerateDartLintsTask extends AnalysisTask {
-
   ///The compilation units that comprise the library, with the defining
   ///compilation unit appearing first in the list.
   final List<TimestampedData<CompilationUnit>> _units;
 
   /// The element model for the library being analyzed.
   final LibraryElement libraryElement;
 
   /// A mapping of analyzed sources to their associated lint warnings.
   /// May be [null] if the task has not been performed or if analysis did not
   /// complete normally.
@@ skipping 109 matching lines @@
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGetContentTask(this);
 
   @override
   void internalPerform() {
     _complete = true;
     try {
       TimestampedData<String> data = context.getContents(source);
       _content = data.data;
       _modificationTime = data.modificationTime;
-      AnalysisEngine.instance.instrumentationService.logFileRead(
-          source.fullName, _modificationTime, _content);
+      AnalysisEngine.instance.instrumentationService
+          .logFileRead(source.fullName, _modificationTime, _content);
     } catch (exception, stackTrace) {
-      errors.add(new AnalysisError(
-          source, 0, 0, ScannerErrorCode.UNABLE_GET_CONTENT, [exception]));
+      if (source.exists()) {
+        errors.add(new AnalysisError(
+            source, 0, 0, ScannerErrorCode.UNABLE_GET_CONTENT, [exception]));
+      }
       throw new AnalysisException("Could not get contents of $source",
           new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * The information cached by an analysis context about an individual HTML file.
  */
 class HtmlEntry extends SourceEntry {
@@ skipping 213 matching lines @@
     _writeStateOn(buffer, "parseErrors", PARSE_ERRORS);
     _writeStateOn(buffer, "parsedUnit", PARSED_UNIT);
     _writeStateOn(buffer, "resolvedUnit", RESOLVED_UNIT);
     _writeStateOn(buffer, "resolutionErrors", RESOLUTION_ERRORS);
     _writeStateOn(buffer, "referencedLibraries", REFERENCED_LIBRARIES);
     _writeStateOn(buffer, "element", ELEMENT);
   }
 }
 
 /**
+ * An event indicating when a source either starts or stops being implicitly
+ * analyzed.
+ */
+class ImplicitAnalysisEvent {
+  /**
+   * The source whose status has changed.
+   */
+  final Source source;
+
+  /**
+   * A flag indicating whether the source is now being analyzed.
+   */
+  final bool isAnalyzed;
+
+  /**
+   * Initialize a newly created event to indicate that the given [source] has
+   * changed it status to match the [isAnalyzed] flag.
+   */
+  ImplicitAnalysisEvent(this.source, this.isAnalyzed);
+
+  @override
+  String toString() =>
+      '${isAnalyzed ? '' : 'not '}analyzing ${source.fullName}';
+}
+
+/**
  * Instances of the class `IncrementalAnalysisCache` hold information used to perform
  * incremental analysis.
  *
  * See [AnalysisContextImpl.setChangedContents].
  */
 class IncrementalAnalysisCache {
   final Source librarySource;
 
   final Source source;
 
   final String oldContents;
 
   final CompilationUnit resolvedUnit;
 
   String _newContents;
 
   int _offset = 0;
 
   int _oldLength = 0;
 
   int _newLength = 0;
 
-  IncrementalAnalysisCache(this.librarySource, this.source, this.resolvedUnit,
-      this.oldContents, String newContents, int offset, int oldLength,
-      int newLength) {
-    this._newContents = newContents;
-    this._offset = offset;
-    this._oldLength = oldLength;
-    this._newLength = newLength;
-  }
+  IncrementalAnalysisCache(
+      this.librarySource,
+      this.source,
+      this.resolvedUnit,
+      this.oldContents,
+      this._newContents,
+      this._offset,
+      this._oldLength,
+      this._newLength);
 
   /**
    * Determine if the cache contains source changes that need to be analyzed
    *
    * @return `true` if the cache contains changes to be analyzed, else `false`
    */
   bool get hasWork => _oldLength > 0 || _newLength > 0;
 
   /**
    * Return the current contents for the receiver's source.
@@ skipping 63 matching lines @@
    * @param source the source being updated (not `null`)
    * @param oldContents the original source contents prior to this update (may be `null`)
    * @param newContents the new contents after this incremental change (not `null`)
    * @param offset the offset at which the change occurred
    * @param oldLength the length of the text being replaced
    * @param newLength the length of the replacement text
    * @param sourceEntry the cached entry for the given source or `null` if none
    * @return the cache used for incremental analysis or `null` if incremental analysis cannot
    *         be performed
    */
-  static IncrementalAnalysisCache update(IncrementalAnalysisCache cache,
-      Source source, String oldContents, String newContents, int offset,
-      int oldLength, int newLength, SourceEntry sourceEntry) {
+  static IncrementalAnalysisCache update(
+      IncrementalAnalysisCache cache,
+      Source source,
+      String oldContents,
+      String newContents,
+      int offset,
+      int oldLength,
+      int newLength,
+      SourceEntry sourceEntry) {
     // Determine the cache resolved unit
     Source librarySource = null;
     CompilationUnit unit = null;
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       List<Source> librarySources = dartEntry.librariesContaining;
       if (librarySources.length == 1) {
         librarySource = librarySources[0];
         if (librarySource != null) {
           unit = dartEntry.getValueInLibrary(
@@ skipping 405 matching lines @@
 class ObsoleteSourceAnalysisException extends AnalysisException {
   /**
    * The source that was removed while it was being analyzed.
    */
   Source _source;
 
   /**
    * Initialize a newly created exception to represent the removal of the given
    * [source].
    */
-  ObsoleteSourceAnalysisException(Source source) : super(
-          "The source '${source.fullName}' was removed while it was being analyzed") {
+  ObsoleteSourceAnalysisException(Source source)
+      : super(
+            "The source '${source.fullName}' was removed while it was being analyzed") {
     this._source = source;
   }
 
   /**
    * Return the source that was removed while it was being analyzed.
    */
   Source get source => _source;
 }
 
 /**
@@ skipping 703 matching lines @@
     }
     return null;
   }
 }
 
 /**
  * An visitor that removes any resolution information from an AST structure when
  * used to visit that structure.
  */
 class ResolutionEraser extends GeneralizingAstVisitor<Object> {
+  /**
+   * A flag indicating whether the elements associated with declarations should
+   * be erased.
+   */
+  bool eraseDeclarations = true;
+
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitAssignmentExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitBinaryExpression(node);
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     node.target = null;
     return super.visitBreakStatement(node);
   }
 
   @override
   Object visitCompilationUnit(CompilationUnit node) {
-    node.element = null;
+    if (eraseDeclarations) {
+      node.element = null;
+    }
     return super.visitCompilationUnit(node);
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
-    node.element = null;
+    if (eraseDeclarations) {
+      node.element = null;
+    }
     return super.visitConstructorDeclaration(node);
   }
 
   @override
   Object visitConstructorName(ConstructorName node) {
     node.staticElement = null;
     return super.visitConstructorName(node);
   }
 
   @override
   Object visitContinueStatement(ContinueStatement node) {
     node.target = null;
     return super.visitContinueStatement(node);
   }
 
   @override
   Object visitDirective(Directive node) {
-    node.element = null;
+    if (eraseDeclarations) {
+      node.element = null;
+    }
     return super.visitDirective(node);
   }
 
   @override
   Object visitExpression(Expression node) {
     node.staticType = null;
     node.propagatedType = null;
     return super.visitExpression(node);
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
-    node.element = null;
+    if (eraseDeclarations) {
+      node.element = null;
+    }
     return super.visitFunctionExpression(node);
   }
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitFunctionExpressionInvocation(node);
   }
 
@@ skipping 26 matching lines @@
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     node.staticElement = null;
     return super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    node.staticElement = null;
+    if (eraseDeclarations || !node.inDeclarationContext()) {
+      node.staticElement = null;
+    }
     node.propagatedElement = null;
     return super.visitSimpleIdentifier(node);
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     node.staticElement = null;
     return super.visitSuperConstructorInvocation(node);
   }
 
   /**
    * Remove any resolution information from the given AST structure.
    */
-  static void erase(AstNode node) {
-    node.accept(new ResolutionEraser());
+  static void erase(AstNode node, {bool eraseDeclarations: true}) {
+    ResolutionEraser eraser = new ResolutionEraser();
+    eraser.eraseDeclarations = eraseDeclarations;
+    node.accept(eraser);
   }
 }
 
 /**
  * The information produced by resolving a compilation unit as part of a
  * specific library.
  */
 class ResolutionState {
   /**
    * The next resolution state or `null` if none.
@@ skipping 492 matching lines @@
     ResolverVisitor resolverVisitor = new ResolverVisitor(
         _libraryElement, source, typeProvider, errorListener,
         inheritanceManager: inheritanceManager);
     unit.accept(resolverVisitor);
     //
     // Perform additional error checking.
     //
     PerformanceStatistics.errors.makeCurrentWhile(() {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       ErrorVerifier errorVerifier = new ErrorVerifier(
-          errorReporter, _libraryElement, typeProvider, inheritanceManager);
+          errorReporter,
+          _libraryElement,
+          typeProvider,
+          inheritanceManager,
+          context.analysisOptions.enableSuperMixins);
       unit.accept(errorVerifier);
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _libraryElement, typeProvider);
 //       unit.accept(constantVerifier);
     });
     //
     // Capture the results.
@@ skipping 1073 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }