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<ChangeSet> 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<ChangeSet> _onSourcesChangedController;

[Brian Wilkerson, 2014/11/18 15:22:19]

Shouldn't this be StreamController<SourcesChangedEvent>?

[danrubel, 2014/11/19 01:02:17]

Good point and addressed as per discussion.

+
+  /**
+   * The stream that is notified when sources have been added or removed,
+   * or the source's content has changed.
+   */
+  Stream<ChangeSet> _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<ChangeSet>();
+    _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<ChangeSet> 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(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)) {
+      ChangeSet changeSet = new ChangeSet();
+      changeSet.changedRange(source, contents, offset, oldLength, newLength);
+      _onSourcesChangedController.add(changeSet);
     }
   }
 
   @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)) {
+      ChangeSet changeSet = new ChangeSet();
+      changeSet.changedContent(source, contents);
+      _onSourcesChangedController.add(changeSet);
     }
   }
 
   @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 7652 matching lines @@
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
+  Stream<ChangeSet> 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 4141 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }