add source changed event stream

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;
+import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/task/task_dart.dart';
 
 import 'ast.dart';
 import 'constant.dart';
 import 'element.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'html.dart' as ht;
@@ skipping 352 matching lines @@
   /**
    * Return an array containing all of the sources known to this context that represent the defining
    * compilation unit of a library. The contents of the array can be incomplete.
    *
    * @return the sources known to this context that represent the defining compilation unit of a
    *         library
    */
   List<Source> get librarySources;
 
   /**
+   * 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.
    *
    * @return the sources known to this context and are not safe for refactoring
    */
   List<Source> get refactoringUnsafeSources;
 
   /**
    * Return the source factory used to create the sources that can be analyzed in this context.
@@ skipping 575 matching lines @@
    * The object used to manage the list of sources that need to be analyzed.
    */
   WorkManager _workManager = new WorkManager();
 
   /**
    * The set of [AngularApplication] in this context.
    */
   Set<AngularApplication> _angularApplications = new Set();
 
   /**
+   * The controller for sending [SourcesChangedEvent]s.
+   */
+  StreamController<SourcesChangedEvent> _onSourcesChangedController;
+
+  /**
+   * The stream that is notified when sources have been added or removed,
+   * or the source's content has changed.
+   */
+  Stream<SourcesChangedEvent> _onSourcesChanged;
+
+  /**
    * The listeners that are to be notified when various analysis results are produced in this
    * context.
    */
   List<AnalysisListener> _listeners = new List<AnalysisListener>();
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _privatePartition = new UniversalCachePartition(
         this,
         AnalysisOptionsImpl.DEFAULT_CACHE_SIZE,
         new AnalysisContextImpl_ContextRetentionPolicy(this));
     _cache = createCacheFromSourceFactory(null);
+    _onSourcesChangedController = new StreamController<SourcesChangedEvent>();
+    _onSourcesChanged = _onSourcesChangedController.stream.asBroadcastStream();
   }
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute =
         this._options.analyzeAngular != options.analyzeAngular ||
         this._options.analyzeFunctionBodies != options.analyzeFunctionBodies ||
@@ skipping 207 matching lines @@
     }
     if (hasBlockedTask) {
       // All of the analysis work is blocked waiting for an asynchronous task
       // to complete.
       return WaitForAsyncTask.instance;
     }
     return null;
   }
 
   @override
+  Stream<SourcesChangedEvent> get onSourcesChanged => _onSourcesChanged;
+
+  @override
   List<Source> get prioritySources => _priorityOrder;
 
   @override
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is DartEntry) {
         Source source = iterator.key;
@@ skipping 148 matching lines @@
     for (Source source in changeSet.changedSources) {
       if (_contentCache.getContents(source) != null) {
         // This source is overridden in the content cache, so the change will
         // have no effect. Just ignore it to avoid wasting time doing
         // re-analysis.
         continue;
       }
       _sourceChanged(source);
     }
     changeSet.changedContents.forEach((Source key, String value) {
-      setContents(key, value);
+      _contentsChanged(key, value);
     });
     changeSet.changedRanges.forEach(
         (Source source, ChangeSet_ContentChange change) {
-      setChangedContents(
+      _contentRangeChanged(
           source,
           change.contents,
           change.offset,
           change.oldLength,
           change.newLength);
     });
     for (Source source in changeSet.deletedSources) {
       _sourceDeleted(source);
     }
     for (Source source in removedSources) {
@@ skipping 22 matching lines @@
         SourceEntry entry = _getReadableSourceEntry(source);
         if (entry is DartEntry) {
           entry.invalidateAllResolutionInformation(false);
           _workManager.add(source, _computePriority(entry));
         } else if (entry is HtmlEntry) {
           entry.invalidateAllResolutionInformation(false);
           _workManager.add(source, SourcePriority.HTML);
         }
       }
     }
+    _onSourcesChangedController.add(new SourcesChangedEvent(changeSet));
   }
 
   @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
     }
     Source source = element.source;
     if (source == null) {
       return null;
@@ skipping 827 matching lines @@
 
   @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   @override
   void setChangedContents(Source source, String contents, int offset,
       int oldLength, int newLength) {
-    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));
-        }
-        _sourceChanged(source);
-        SourceEntry sourceEntry = _cache.get(source);
-        if (sourceEntry != null) {
-          sourceEntry.modificationTime =
-              _contentCache.getModificationStamp(source);
-          sourceEntry.setValue(SourceEntry.CONTENT, contents);
-        }
-      }
-    } else if (originalContents != null) {
-      _incrementalAnalysisCache =
-          IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-      _sourceChanged(source);
+    if (_contentRangeChanged(source, contents, offset, oldLength, newLength)) {
+      _onSourcesChangedController.add(
+          new SourcesChangedEvent.changedRange(
+              source, contents, offset, oldLength, newLength));
     }
   }
 
   @override
   void setContents(Source source, String contents) {
-    String originalContents = _contentCache.setContents(source, contents);
-    if (contents != null) {
-      if (contents != originalContents) {
-        _incrementalAnalysisCache =
-            IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-        _sourceChanged(source);
-        SourceEntry sourceEntry = _cache.get(source);
-        if (sourceEntry != null) {
-          sourceEntry.modificationTime =
-              _contentCache.getModificationStamp(source);
-          sourceEntry.setValue(SourceEntry.CONTENT, contents);
-        }
-      }
-    } else if (originalContents != null) {
-      _incrementalAnalysisCache =
-          IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-      _sourceChanged(source);
+    if (_contentsChanged(source, contents)) {
+      _onSourcesChangedController.add(
+          new SourcesChangedEvent.changedContent(source, contents));
     }
   }
 
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
       DataDescriptor rowDesc, CacheState state)) {
     void handleCacheItem(Source source, SourceEntry dartEntry,
         DataDescriptor descriptor) {
       callback(source, dartEntry, descriptor, dartEntry.getState(descriptor));
     }
@@ skipping 515 matching lines @@
   bool _containsAny(List<Source> sources, List<Source> targetSources) {
     for (Source targetSource in targetSources) {
       if (_contains(sources, targetSource)) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Set the contents of the given source to the given contents and mark the source as having
+   * changed. The additional offset and length information is used by the context to determine what
+   * reanalysis is necessary. [setChangedContents] triggers a source changed event
+   * where as this method does not.
+   *
+   * @param source the source whose contents are being overridden
+   * @param contents the text to replace the range in the current contents
+   * @param offset the offset into the current contents
+   * @param oldLength the number of characters in the original contents that were replaced
+   * @param newLength the number of characters in the replacement text
+   */
+  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));
+        }
+        _sourceChanged(source);
+        changed = true;
+        SourceEntry sourceEntry = _cache.get(source);
+        if (sourceEntry != null) {
+          sourceEntry.modificationTime = _contentCache.getModificationStamp(source);
+          sourceEntry.setValue(SourceEntry.CONTENT, contents);
+        }
+      }
+    } else if (originalContents != null) {
+      _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
+      _sourceChanged(source);
+      changed = true;
+    }
+    return changed;
+  }
+
+  /**
+   * Set the contents of the given source to the given contents and mark the source as having
+   * changed. This has the effect of overriding the default contents of the source. If the contents
+   * are `null` the override is removed so that the default contents will be returned.
+   * [setContents] triggers a source changed event where as this method does not.
+   *
+   * @param source the source whose contents are being overridden
+   * @param contents the new contents of the source
+   */
+  bool _contentsChanged(Source source, String contents) {
+    bool changed = false;
+    String originalContents = _contentCache.setContents(source, contents);
+    if (contents != null) {
+      if (contents != originalContents) {
+        _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
+        _sourceChanged(source);
+        changed = true;
+        SourceEntry sourceEntry = _cache.get(source);
+        if (sourceEntry != null) {
+          sourceEntry.modificationTime = _contentCache.getModificationStamp(source);
+          sourceEntry.setValue(SourceEntry.CONTENT, contents);
+        }
+      }
+    } else if (originalContents != null) {
+      _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
+      _sourceChanged(source);
+      changed = true;
+    }
+    return changed;
+  }
+
+  /**
    * Create a [BuildUnitElementTask] for the given [source].
    */
   AnalysisContextImpl_TaskData _createBuildUnitElementTask(Source source,
       DartEntry dartEntry, Source librarySource) {
     CompilationUnit unit = dartEntry.resolvableCompilationUnit;
     if (unit == null) {
       return _createParseDartTask(source, dartEntry);
     }
     return new AnalysisContextImpl_TaskData(
         new BuildUnitElementTask(this, source, librarySource, unit),
@@ skipping 5553 matching lines @@
    *
    * @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;
   }
 }
 
-
 /**
  * A `DartEntry` maintains the information cached by an analysis context about
  * an individual Dart file.
  */
 class DartEntry extends SourceEntry {
   /**
    * The data descriptor representing the errors reported during Angular
    * resolution.
    */
   static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS =
@@ skipping 852 matching lines @@
     _writeStateOn(buffer, "includedParts", INCLUDED_PARTS);
     _writeStateOn(buffer, "element", ELEMENT);
     _writeStateOn(buffer, "publicNamespace", PUBLIC_NAMESPACE);
     _writeStateOn(buffer, "clientServer", IS_CLIENT);
     _writeStateOn(buffer, "launchable", IS_LAUNCHABLE);
     _writeStateOn(buffer, "angularErrors", ANGULAR_ERRORS);
     _resolutionState._writeOn(buffer);
   }
 }
 
+
 /**
  * Instances of the class `DataDescriptor` are immutable constants representing data that can
  * be stored in the cache.
  */
 class DataDescriptor<E> {
   /**
    * The name of the descriptor, used for debugging purposes.
    */
   final String _name;
 
@@ skipping 1206 matching lines @@
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
+  Stream<SourcesChangedEvent> get onSourcesChanged => _basis.onSourcesChanged;
+
+  @override
   List<Source> get prioritySources {
     InstrumentationBuilder instrumentation =
         Instrumentation.builder2("Analysis-getPrioritySources");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.prioritySources;
     } finally {
       instrumentation.log();
     }
@@ skipping 3844 matching lines @@
       PRIORITY_PART,
       LIBRARY,
       UNKNOWN,
       NORMAL_PART,
       HTML];
 
   const SourcePriority(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
+ * [SourcesChangedEvent] indicates which sources have been added, removed,
+ * or whose contents have changed.
+ */
+class SourcesChangedEvent {
+
+  /**
+   * The internal representation of what has changed.
+   * Clients should not access this field directly.
+   */
+  final ChangeSet _changeSet;
+
+  /**
+   * Construct an instance representing the given changes.
+   */
+  SourcesChangedEvent(ChangeSet changeSet) : _changeSet = changeSet;
+
+  /**
+   * Construct an instance representing a source content change.
+   */
+  factory SourcesChangedEvent.changedContent(Source source, String contents) {
+    ChangeSet changeSet = new ChangeSet();
+    changeSet.changedContent(source, contents);
+    return new SourcesChangedEvent(changeSet);
+  }
+
+  /**
+   * Construct an instance representing a source content change.
+   */
+  factory SourcesChangedEvent.changedRange(Source source, String contents,
+      int offset, int oldLength, int newLength) {
+    ChangeSet changeSet = new ChangeSet();
+    changeSet.changedRange(source, contents, offset, oldLength, newLength);
+    return new SourcesChangedEvent(changeSet);
+  }
+
+  /**
+   * Return the collection of sources for which content has changed.
+   */
+  Iterable<Source> get changedSources {
+    List<Source> changedSources = new List.from(_changeSet.changedSources);
+    changedSources.addAll(_changeSet.changedContents.keys);
+    changedSources.addAll(_changeSet.changedRanges.keys);
+    return changedSources;
+  }
+
+  /**
+   * Return `true` if any sources were added.
+   */
+  bool get wereSourcesAdded => _changeSet.addedSources.length > 0;
+
+  /**
+   * Return `true` if any sources were removed or deleted.
+   */
+  bool get wereSourcesRemovedOrDeleted => _changeSet.removedSources.length > 0
+      || _changeSet.removedContainers.length > 0
+      || _changeSet.deletedSources.length > 0;
+}
+
+/**
  * Instances of the class `TimestampedData` represent analysis data for which we have a
  * modification time.
  */
 class TimestampedData<E> {
   /**
    * The modification time of the source from which the data was created.
    */
   final int modificationTime;
 
   /**
@@ skipping 277 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }