New analyzer snapshot.

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'dart:collection';
@@ skipping 233 matching lines @@
  * needed analysis and get notified of the consequent changes to the analysis results. This
  * mechanism is realized by the method [performAnalysisTask].
  *
  * Analysis engine allows for having more than one context. This can be used, for example, to
  * perform one analysis based on the state of files on disk and a separate analysis based on the
  * state of those files in open editors. It can also be used to perform an analysis based on a
  * proposed future state, such as the state after a refactoring.
  */
 abstract class AnalysisContext {
   /**
+   * 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.
    *
    * @param delta a description of the level of analysis that should be performed for some sources
    */
   void applyAnalysisDelta(AnalysisDelta delta);
 
   /**
    * Apply the changes specified by the given change set to this context. Any analysis results that
    * have been invalidated by these changes will be removed.
@@ skipping 455 matching lines @@
   /**
    * Perform the next unit of work required to keep the analysis results up-to-date and return
    * information about the consequent changes to the analysis results. This method can be long
    * running.
    *
    * @return the results of performing the analysis
    */
   AnalysisResult performAnalysisTask();
 
   /**
+   * Remove the given listener from the list of objects that are to be notified when various
+   * analysis results are produced in this context.
+   *
+   * @param listener the listener to be removed
+   */
+  void removeListener(AnalysisListener listener);
+
+  /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source to be parsed and resolved
    * @param library the library containing the source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
    * @see #getResolvedCompilationUnit(Source, LibraryElement)
@@ skipping 195 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 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() : super() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _privatePartition = new UniversalCachePartition(AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
     _cache = createCacheFromSourceFactory(null);
   }
 
   @override
+  void addListener(AnalysisListener listener) {
+    if (!_listeners.contains(listener)) {
+      _listeners.add(listener);
+    }
+  }
+
+  @override
   void addSourceInfo(Source source, SourceEntry info) {
     // This implementation assumes that the access to the cache does not need to be synchronized
     // because no other object can have access to this context while this method is being invoked.
     _cache.put(source, info);
   }
 
   @override
   void applyAnalysisDelta(AnalysisDelta delta) {
     ChangeSet changeSet = new ChangeSet();
     for (MapEntry<Source, AnalysisLevel> entry in getMapEntrySet(delta.analysisLevels)) {
@@ skipping 731 matching lines @@
     }
     int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextAnalysisTask;
     int getEnd = JavaSystem.currentTimeMillis();
     if (task == null && _validateCacheConsistency()) {
       task = nextAnalysisTask;
     }
     if (task == null) {
       return new AnalysisResult(_getChangeNotices(true), getEnd - getStart, null, -1);
     }
-    String taskDescriptor = task.toString();
-    //    if (recentTasks.add(taskDescriptor)) {
-    //      logInformation("Performing task: " + taskDescriptor);
+    String taskDescription = task.toString();
+    //    if (recentTasks.add(taskDescription)) {
+    //      logInformation("Performing task: " + taskDescription);
     //    } else {
     //      if (TRACE_PERFORM_TASK) {
     //        System.out.print("* ");
     //      }
-    //      logInformation("*** Performing repeated task: " + taskDescriptor);
+    //      logInformation("*** Performing repeated task: " + taskDescription);
     //    }
+    _notifyAboutToPerformTask(taskDescription);
     if (_TRACE_PERFORM_TASK) {
-      print(taskDescriptor);
+      print(taskDescription);
     }
     int performStart = JavaSystem.currentTimeMillis();
     try {
       task.perform(_resultRecorder);
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation2("Could not perform analysis task: ${taskDescriptor}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not perform analysis task: ${taskDescription}", exception);
     } on AnalysisException catch (exception) {
       if (exception.cause is! JavaIOException) {
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
-    return new AnalysisResult(_getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
+    List<ChangeNotice> notices = _getChangeNotices(false);
+    int noticeCount = notices.length;
+    for (int i = 0; i < noticeCount; i++) {
+      ChangeNotice notice = notices[i];
+      Source source = notice.source;
+      // TODO(brianwilkerson) Figure out whether the compilation unit is always resolved, or whether
+      // we need to decide whether to invoke the "parsed" or "resolved" method. This might be better
+      // done when recording task results in order to reduce the chance of errors.
+      //      if (notice.getCompilationUnit() != null) {
+      //        notifyResolvedDart(source, notice.getCompilationUnit());
+      //      } else if (notice.getHtmlUnit() != null) {
+      //        notifyResolvedHtml(source, notice.getHtmlUnit());
+      //      }
+      _notifyErrors(source, notice.errors, notice.lineInfo);
+    }
+    return new AnalysisResult(notices, getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
     for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
       Source librarySource = entry.getKey();
       LibraryElement library = entry.getValue();
       //
       // Cache the element in the library's info.
       //
       DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         _recordElementData(dartCopy, library, library.source, htmlSource);
         dartCopy.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS);
         dartCopy.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS);
         dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
         dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
         dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
         dartCopy.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
         dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
         dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, AnalysisError.NO_ERRORS);
         _cache.put(librarySource, dartCopy);
       }
     }
   }
 
   @override
+  void removeListener(AnalysisListener listener) {
+    _listeners.remove(listener);
+  }
+
+  @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
   @override
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => _getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
@@ skipping 2058 matching lines @@
    */
   void _logInformation2(String message, Exception exception) {
     if (exception == null) {
       AnalysisEngine.instance.logger.logInformation(message);
     } else {
       AnalysisEngine.instance.logger.logInformation2(message, exception);
     }
   }
 
   /**
+   * Notify all of the analysis listeners that a task is about to be performed.
+   *
+   * @param taskDescription a human readable description of the task that 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);
+    }
+  }
+
+  /**
+   * Notify all of the analysis listeners that the errors associated with the given source has been
+   * updated to the given errors.
+   *
+   * @param source the source containing the errors that were computed
+   * @param errors the errors that were computed
+   * @param lineInfo the line information associated with the source
+   */
+  void _notifyErrors(Source source, List<AnalysisError> errors, LineInfo lineInfo) {
+    int count = _listeners.length;
+    for (int i = 0; i < count; i++) {
+      _listeners[i].computedErrors(this, source, errors, lineInfo);
+    }
+  }
+
+  /**
+   * 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);
+    }
+  }
+
+  /**
+   * Notify all of the analysis listeners that the given source is now included in the set of
+   * sources that are being analyzed.
+   *
+   * @param source the source that is now being analyzed
+   */
+  void _notifyIncludedSource(Source source) {
+    int count = _listeners.length;
+    for (int i = 0; i < count; i++) {
+      _listeners[i].includedSource(this, source);
+    }
+  }
+
+  /**
+   * Notify all of the analysis listeners that the given Dart source was parsed.
+   *
+   * @param source the source that was parsed
+   * @param unit the result of parsing the source
+   */
+  void _notifyParsedDart(Source source, CompilationUnit unit) {
+    int count = _listeners.length;
+    for (int i = 0; i < count; i++) {
+      _listeners[i].parsedDart(this, source, unit);
+    }
+  }
+
+  /**
+   * Notify all of the analysis listeners that the given HTML source was parsed.
+   *
+   * @param source the source that was parsed
+   * @param unit the result of parsing the source
+   */
+  void _notifyParsedHtml(Source source, ht.HtmlUnit unit) {
+    int count = _listeners.length;
+    for (int i = 0; i < count; i++) {
+      _listeners[i].parsedHtml(this, source, unit);
+    }
+  }
+
+  /**
+   * Notify all of the analysis listeners that the given Dart source was resolved.
+   *
+   * @param source the source that was resolved
+   * @param unit the result of resolving the source
+   */
+  void _notifyResolvedDart(Source source, CompilationUnit unit) {
+    int count = _listeners.length;
+    for (int i = 0; i < count; i++) {
+      _listeners[i].resolvedDart(this, source, unit);
+    }
+  }
+
+  /**
+   * Notify all of the analysis listeners that the given HTML source was resolved.
+   *
+   * @param source the source that was resolved
+   * @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);
+    }
+  }
+
+  /**
    * Updates [HtmlEntry]s that correspond to the previously known and new Angular application
    * information.
    */
   void _recordAngularEntryPoint(HtmlEntryImpl entry, ResolveAngularEntryHtmlTask task) {
     AngularApplication application = task.application;
     if (application != null) {
       _angularApplications.add(application);
       // if this is an entry point, then we already resolved it
       entry.setValue(HtmlEntry.ANGULAR_ERRORS, task.entryErrors);
       // schedule HTML templates analysis
@@ skipping 2319 matching lines @@
    * Indicates a source is not of interest to the client.
    */
   static const AnalysisLevel NONE = const AnalysisLevel('NONE', 3);
 
   static const List<AnalysisLevel> values = const [ALL, ERRORS, RESOLVED, NONE];
 
   const AnalysisLevel(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
+ * The interface `AnalysisListener` defines the behavior of objects that are listening for
+ * results being produced by an analysis context.
+ */
+abstract class AnalysisListener {
+  /**
+   * Reports that a task is about to be performed by the given context.
+   *
+   * @param context the context in which the task is to be performed
+   * @param taskDescription a human readable description of the task that is about to be performed
+   */
+  void aboutToPerformTask(AnalysisContext context, String taskDescription);
+
+  /**
+   * Reports that the errors associated with the given source in the given context has been updated
+   * to the given errors.
+   *
+   * @param context the context in which the new list of errors was produced
+   * @param source the source containing the errors that were computed
+   * @param errors the errors that were computed
+   * @param lineInfo the line information associated with the source
+   */
+  void computedErrors(AnalysisContext context, Source source, List<AnalysisError> errors, LineInfo lineInfo);
+
+  /**
+   * Reports that the given source is no longer included in the set of sources that are being
+   * analyzed by the given analysis context.
+   *
+   * @param context the context in which the source is being analyzed
+   * @param source the source that is no longer being analyzed
+   */
+  void excludedSource(AnalysisContext context, Source source);
+
+  /**
+   * Reports that the given source is now included in the set of sources that are being analyzed by
+   * the given analysis context.
+   *
+   * @param context the context in which the source is being analyzed
+   * @param source the source that is now being analyzed
+   */
+  void includedSource(AnalysisContext context, Source source);
+
+  /**
+   * Reports that the given Dart source was parsed in the given context.
+   *
+   * @param context the context in which the source was parsed
+   * @param source the source that was parsed
+   * @param unit the result of parsing the source in the given context
+   */
+  void parsedDart(AnalysisContext context, Source source, CompilationUnit unit);
+
+  /**
+   * Reports that the given HTML source was parsed in the given context.
+   *
+   * @param context the context in which the source was parsed
+   * @param source the source that was parsed
+   * @param unit the result of parsing the source in the given context
+   */
+  void parsedHtml(AnalysisContext context, Source source, ht.HtmlUnit unit);
+
+  /**
+   * Reports that the given Dart source was resolved in the given context.
+   *
+   * @param context the context in which the source was resolved
+   * @param source the source that was resolved
+   * @param unit the result of resolving the source in the given context
+   */
+  void resolvedDart(AnalysisContext context, Source source, CompilationUnit unit);
+
+  /**
+   * Reports that the given HTML source was resolved in the given context.
+   *
+   * @param context the context in which the source was resolved
+   * @param source the source that was resolved
+   * @param unit the result of resolving the source in the given context
+   */
+  void resolvedHtml(AnalysisContext context, Source source, ht.HtmlUnit unit);
+}
+
+/**
  * The interface `AnalysisOptions` defines the behavior of objects that provide access to a
  * set of analysis options used to control the behavior of an analysis context.
  */
 abstract class AnalysisOptions {
   /**
    * Return `true` if analysis is to analyze Angular.
    *
    * @return `true` if analysis is to analyze Angular
    */
   bool get analyzeAngular;
@@ skipping 5157 matching lines @@
    * Create a new [InstrumentedAnalysisContextImpl] with a specified basis context, aka the
    * context to wrap and instrument.
    *
    * @param context some [InstrumentedAnalysisContext] to wrap and instrument
    */
   InstrumentedAnalysisContextImpl.con1(InternalAnalysisContext context) {
     _basis = context;
   }
 
   @override
+  void addListener(AnalysisListener listener) {
+    _basis.addListener(listener);
+  }
+
+  @override
   void addSourceInfo(Source source, SourceEntry info) {
     _basis.addSourceInfo(source, info);
   }
 
   @override
   void applyAnalysisDelta(AnalysisDelta delta) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-updateAnalysis");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
@@ skipping 583 matching lines @@
       instrumentation.log2(2);
     }
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     _basis.recordLibraryElements(elementMap);
   }
 
   @override
+  void removeListener(AnalysisListener listener) {
+    _basis.removeListener(listener);
+  }
+
+  @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit(unitSource, library);
     } on AnalysisException catch (e, stackTrace) {
       _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
@@ skipping 3290 matching lines @@
     _index++;
     if (_index >= WorkManager_this._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < WorkManager_this._workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }