Fix for dartbug.com/22656- analysis.flushedResults implementation.

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 "dart:math" as math;
@@ skipping 401 matching lines @@
    */
   String get name;
 
   /**
    * Set the client-provided name used to identify this context to the given
    * [name].
    */
   set name(String name);
 
   /**
-   * Returns a type provider for this context or throws [AnalysisException] if
-   * `dart:core` or `dart:async` cannot be resolved.
-   */
-  TypeProvider get typeProvider;
-
-  /**
    * The stream that is notified when sources have been added or removed,
    * or the source's content has changed.
    */
   Stream<SourcesChangedEvent> get onSourcesChanged;
 
   /**
    * Return an array containing all of the sources known to this context and their resolution state
    * is not valid or flush. So, these sources are not safe to update during refactoring, because we
    * may be don't know all the references in them.
    *
@@ skipping 12 matching lines @@
    * Set the source factory used to create the sources that can be analyzed in this context to the
    * given source factory. Clients can safely assume that all analysis results have been
    * invalidated.
    *
    * @param factory the source factory used to create the sources that can be analyzed in this
    *          context
    */
   void set sourceFactory(SourceFactory factory);
 
   /**
+   * Return an array containing all of the sources known to this context.
+   *
+   * @return all of the sources known to this context
+   */
+  List<Source> get sources;
+
+  /**
+   * Returns a type provider for this context or throws [AnalysisException] if
+   * `dart:core` or `dart:async` cannot be resolved.
+   */
+  TypeProvider get typeProvider;
+
+  /**
    * Add the given listener to the list of objects that are to be notified when various analysis
    * results are produced in this context.
    *
    * @param listener the listener to be added
    */
   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.
@@ skipping 650 matching lines @@
         new StreamController<SourcesChangedEvent>.broadcast();
   }
 
   @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.generateImplicitErrors !=
+            options.generateImplicitErrors ||
         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.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.
       //
       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.analyzeFunctionBodiesPredicate =
         options.analyzeFunctionBodiesPredicate;
-        this._options.generateImplicitErrors = options.generateImplicitErrors;
+    this._options.generateImplicitErrors = options.generateImplicitErrors;
     this._options.generateSdkErrors = options.generateSdkErrors;
     this._options.dart2jsHint = options.dart2jsHint;
     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;
     _generateImplicitErrors = options.generateImplicitErrors;
     _generateSdkErrors = options.generateSdkErrors;
@@ skipping 266 matching lines @@
       _sourceFactory.context = null;
     }
     factory.context = this;
     _sourceFactory = factory;
     _coreLibrarySource = _sourceFactory.forUri(DartSdk.DART_CORE);
     _asyncLibrarySource = _sourceFactory.forUri(DartSdk.DART_ASYNC);
     _cache = createCacheFromSourceFactory(factory);
     _invalidateAllLocalResolutionInformation(true);
   }
 
+  @override
+  List<Source> get sources {
+    List<Source> sources = new List<Source>();
+    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      sources.add(iterator.key);
+    }
+    return sources;
+  }
+
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
    */
   List<Source> get sourcesNeedingProcessing {
     HashSet<Source> sources = new HashSet<Source>();
     bool hintsEnabled = _options.hint;
@@ skipping 1165 matching lines @@
             }
             callback(librarySource, sourceEntry, descriptor,
                 sourceEntry.getStateInLibrary(descriptor, librarySource));
           }
         }
       }
     }
   }
 
   /**
-   * Return `true` if errors should be produced for the given [source]. The
-   * [dartEntry] associated with the source is passed in for efficiency.
-   */
-  bool _shouldErrorsBeAnalyzed(Source source, DartEntry dartEntry) {
-    if (source.isInSystemLibrary) {
-      return _generateSdkErrors;
-    } else if (!dartEntry.explicitlyAdded) {
-      return _generateImplicitErrors;
-    } else {
-      return true;
-    }
-  }
-
-  /**
    * Visit all entries of the content cache.
    */
   void visitContentCache(ContentCacheVisitor visitor) {
     _contentCache.accept(visitor);
   }
 
   /**
    * Record that we have accessed the AST structure associated with the given source. At the moment,
    * there is no differentiation between the parsed and resolved forms of the AST.
    *
@@ skipping 1670 matching lines @@
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
     // reset unit in the notification, it is out of date now
     ChangeNoticeImpl notice = _pendingNotices[source];
     if (notice != null) {
       notice.resolvedDartUnit = null;
       notice.resolvedHtmlUnit = null;
     }
   }
 
+  /**
+   * Record the results produced by performing a [task] and return the cache
+   * entry associated with the results.
+   */
+  DartEntry _recordBuildUnitElementTask(BuildUnitElementTask task) {
+    Source source = task.source;
+    Source library = task.library;
+    DartEntry dartEntry = _cache.get(source);
+    CaughtException thrownException = task.exception;
+    if (thrownException != null) {
+      dartEntry.recordBuildElementErrorInLibrary(library, thrownException);
+      throw new AnalysisException('<rethrow>', thrownException);
+    }
+    dartEntry.setValueInLibrary(DartEntry.BUILT_UNIT, library, task.unit);
+    dartEntry.setValueInLibrary(
+        DartEntry.BUILT_ELEMENT, library, task.unitElement);
+    ChangeNoticeImpl notice = _getNotice(source);
+    LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
+    notice.setErrors(dartEntry.allErrors, lineInfo);
+    return dartEntry;
+  }
+
 //  /**
 //   * 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);
 //    }
 //  }
 
   /**
-   * Record the results produced by performing a [task] and return the cache
-   * entry associated with the results.
-   */
-  DartEntry _recordBuildUnitElementTask(BuildUnitElementTask task) {
-    Source source = task.source;
-    Source library = task.library;
-    DartEntry dartEntry = _cache.get(source);
-    CaughtException thrownException = task.exception;
-    if (thrownException != null) {
-      dartEntry.recordBuildElementErrorInLibrary(library, thrownException);
-      throw new AnalysisException('<rethrow>', thrownException);
-    }
-    dartEntry.setValueInLibrary(DartEntry.BUILT_UNIT, library, task.unit);
-    dartEntry.setValueInLibrary(
-        DartEntry.BUILT_ELEMENT, library, task.unitElement);
-    ChangeNoticeImpl notice = _getNotice(source);
-    LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
-    notice.setErrors(dartEntry.allErrors, lineInfo);
-    return dartEntry;
-  }
-
-  /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @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, LibraryElement library,
       Source librarySource, Source htmlSource) {
@@ skipping 375 matching lines @@
       if (_priorityOrder[i] != source) {
         newOrder.add(_priorityOrder[i]);
       }
     }
     if (newOrder.length < count) {
       analysisPriorityOrder = newOrder;
     }
   }
 
   /**
+   * Return `true` if errors should be produced for the given [source]. The
+   * [dartEntry] associated with the source is passed in for efficiency.
+   */
+  bool _shouldErrorsBeAnalyzed(Source source, DartEntry dartEntry) {
+    if (source.isInSystemLibrary) {
+      return _generateSdkErrors;
+    } else if (!dartEntry.explicitlyAdded) {
+      return _generateImplicitErrors;
+    } else {
+      return true;
+    }
+  }
+
+  /**
    * Create an entry for the newly added [source] and invalidate any sources
    * that referenced the source before it existed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on
    * [cacheLock].
    */
   void _sourceAvailable(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       sourceEntry = _createSourceEntry(source, true);
@@ skipping 7330 matching lines @@
   visitElement(Element element) {
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {}