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 'java_core.dart';
@@ skipping 3481 matching lines @@
         logInformation("Added Dart sources, invalidating all resolution information");
         for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
           Source source = mapEntry.getKey();
           SourceEntry sourceEntry = mapEntry.getValue();
           if (!source.isInSystemLibrary && sourceEntry is DartEntry) {
             DartEntry dartEntry = sourceEntry;
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             removeFromParts(source, dartEntry);
             dartCopy.invalidateAllResolutionInformation();
             mapEntry.setValue(dartCopy);
-            WorkManagerPriority priority = WorkManagerPriority.UNKNOWN;
+            SourcePriority priority = SourcePriority.UNKNOWN;
             SourceKind kind = dartCopy.kind;
             if (identical(kind, SourceKind.LIBRARY)) {
-              priority = WorkManagerPriority.LIBRARY;
+              priority = SourcePriority.LIBRARY;
             } else if (identical(kind, SourceKind.PART)) {
-              priority = WorkManagerPriority.NORMAL_PART;
+              priority = SourcePriority.NORMAL_PART;
             }
             _workManager.add(source, priority);
           }
         }
       }
     }
   }
 
   String computeDocumentationComment(Element element) {
     if (element == null) {
@@ skipping 788 matching lines @@
                   recordElementData(dartEntry, dartCopy, library.libraryElement, librarySource, htmlSource);
                 }
                 _cache.storedAst(source);
               } else {
                 dartCopy.recordResolutionError();
                 _cache.remove(source);
               }
               dartCopy.exception = thrownException;
               _cache.put(source, dartCopy);
               if (source != librarySource) {
-                _workManager.add(source, WorkManagerPriority.PRIORITY_PART);
+                _workManager.add(source, SourcePriority.PRIORITY_PART);
               }
               if (source == unitSource) {
                 unitEntry = dartCopy;
               }
               ChangeNoticeImpl notice = getNotice(source);
               notice.compilationUnit = unit;
               notice.setErrors(dartCopy.allErrors, lineInfo);
             }
           }
         } else {
@@ skipping 1037 matching lines @@
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(htmlCopy);
       } else if (sourceEntry is DartEntry) {
         DartEntry dartEntry = sourceEntry;
         removeFromParts(source, dartEntry);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(dartCopy);
-        _workManager.add(source, WorkManagerPriority.UNKNOWN);
+        _workManager.add(source, SourcePriority.UNKNOWN);
       }
     }
   }
 
   /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param librarySource the source of the library being invalidated
    * @param writer the writer to which debugging information should be written
    */
   void invalidateLibraryResolution(Source librarySource, PrintStringWriter writer) {
     // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these caches if
     // the public namespace hasn't changed, which will be a fairly common case. The question is
     // whether we can afford the time to compute the namespace to look for differences.
     DartEntry libraryEntry = getReadableDartEntry(librarySource);
     if (libraryEntry != null) {
       List<Source> includedParts = libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
       DartEntryImpl libraryCopy = libraryEntry.writableCopy;
       int oldTime = libraryCopy.modificationTime;
       libraryCopy.invalidateAllResolutionInformation();
       _cache.put(librarySource, libraryCopy);
-      _workManager.add(librarySource, WorkManagerPriority.LIBRARY);
+      _workManager.add(librarySource, SourcePriority.LIBRARY);
       if (writer != null) {
         writer.println("  Invalidated library source: ${debuggingString(librarySource)} (previously modified at ${oldTime})");
       }
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
           DartEntryImpl partCopy = partEntry.writableCopy;
           oldTime = partCopy.modificationTime;
           if (partEntry != libraryCopy) {
             partCopy.removeContainingLibrary(librarySource);
-            _workManager.add(librarySource, WorkManagerPriority.NORMAL_PART);
+            _workManager.add(librarySource, SourcePriority.NORMAL_PART);
           }
           partCopy.invalidateAllResolutionInformation();
           _cache.put(partSource, partCopy);
           if (writer != null) {
             writer.println("  Invalidated part source: ${debuggingString(partSource)} (previously modified at ${oldTime})");
           }
         }
       }
     }
   }
@@ skipping 86 matching lines @@
         if (angularElement is AngularComponentElement) {
           AngularComponentElement component = angularElement;
           Source templateSource = component.templateSource;
           if (templateSource != null) {
             HtmlEntry htmlEntry = getReadableHtmlEntry(templateSource);
             HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
             htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, app);
             htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, component);
             htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
             _cache.put(templateSource, htmlCopy);
-            _workManager.add(templateSource, WorkManagerPriority.HTML);
+            _workManager.add(templateSource, SourcePriority.HTML);
           }
         }
       }
     }
     // remember Angular application
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, app);
     entry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
   }
 
   /**
@@ skipping 80 matching lines @@
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the source
           // will be re-verified using the up-to-date sources.
           //
           //          dartCopy.setState(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.INVALID);
           removeFromParts(source, dartEntry);
           dartCopy.invalidateAllInformation();
           dartCopy.modificationTime = sourceTime;
           _cache.removedAst(source);
-          _workManager.add(source, WorkManagerPriority.UNKNOWN);
+          _workManager.add(source, SourcePriority.UNKNOWN);
         } else {
           //
           // We could not determine whether the sources were up-to-date or out-of-date. Mark the
           // cache so that we won't attempt to re-verify the source until there's a good chance
           // that we'll be able to do so without error.
           //
           dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
         }
         dartCopy.exception = thrownException;
         _cache.put(source, dartCopy);
@@ skipping 82 matching lines @@
             if (thrownException == null || resultTime >= 0) {
               //
               // The analysis was performed on out-of-date sources. Mark the cache so that the sources
               // will be re-analyzed using the up-to-date sources.
               //
               //              dartCopy.setState(DartEntry.HINTS, librarySource, CacheState.INVALID);
               removeFromParts(unitSource, dartEntry);
               dartCopy.invalidateAllInformation();
               dartCopy.modificationTime = sourceTime;
               _cache.removedAst(unitSource);
-              _workManager.add(unitSource, WorkManagerPriority.UNKNOWN);
+              _workManager.add(unitSource, SourcePriority.UNKNOWN);
             } else {
               //
               // We could not determine whether the sources were up-to-date or out-of-date. Mark the
               // cache so that we won't attempt to re-analyze the sources until there's a good chance
               // that we'll be able to do so without error.
               //
               dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
             }
             dartCopy.exception = thrownException;
             _cache.put(unitSource, dartCopy);
@@ skipping 57 matching lines @@
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
           }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
           LineInfo lineInfo = task.lineInfo;
           dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
           if (task.hasPartOfDirective() && !task.hasLibraryDirective()) {
             dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
-            _workManager.add(source, WorkManagerPriority.NORMAL_PART);
+            _workManager.add(source, SourcePriority.NORMAL_PART);
           } else {
             dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
             dartCopy.containingLibrary = source;
-            _workManager.add(source, WorkManagerPriority.LIBRARY);
+            _workManager.add(source, SourcePriority.LIBRARY);
           }
           dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
           dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
           _cache.storedAst(source);
           ChangeNoticeImpl notice = getNotice(source);
           notice.setErrors(dartEntry.allErrors, lineInfo);
           // Verify that the incrementally parsed and resolved unit in the incremental cache
           // is structurally equivalent to the fully parsed unit
           _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
         } else {
@@ skipping 10 matching lines @@
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
           //          dartCopy.recordParseNotInProcess();
           removeFromParts(source, dartEntry);
           dartCopy.invalidateAllInformation();
           dartCopy.modificationTime = sourceTime;
           _cache.removedAst(source);
-          _workManager.add(source, WorkManagerPriority.UNKNOWN);
+          _workManager.add(source, SourcePriority.UNKNOWN);
         } else {
           //
           // We could not determine whether the sources were up-to-date or out-of-date. Mark the
           // cache so that we won't attempt to re-analyze the sources until there's a good chance
           // that we'll be able to do so without error.
           //
           dartCopy.recordParseError();
         }
         dartCopy.exception = thrownException;
         _cache.put(source, dartCopy);
@@ skipping 316 matching lines @@
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
           //          dartCopy.recordDependencyNotInProcess();
           removeFromParts(source, dartEntry);
           dartCopy.invalidateAllInformation();
           dartCopy.modificationTime = sourceTime;
           _cache.removedAst(source);
-          _workManager.add(source, WorkManagerPriority.UNKNOWN);
+          _workManager.add(source, SourcePriority.UNKNOWN);
         } else {
           //
           // We could not determine whether the sources were up-to-date or out-of-date. Mark the
           // cache so that we won't attempt to re-analyze the sources until there's a good chance
           // that we'll be able to do so without error.
           //
           dartCopy.setState(DartEntry.EXPORTED_LIBRARIES, CacheState.ERROR);
           dartCopy.setState(DartEntry.IMPORTED_LIBRARIES, CacheState.ERROR);
           dartCopy.setState(DartEntry.INCLUDED_PARTS, CacheState.ERROR);
         }
@@ skipping 59 matching lines @@
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
           //          if (dartCopy.getState(DartEntry.RESOLVED_UNIT) == CacheState.IN_PROCESS) {
           //            dartCopy.setState(DartEntry.RESOLVED_UNIT, librarySource, CacheState.INVALID);
           //          }
           removeFromParts(unitSource, dartEntry);
           dartCopy.invalidateAllInformation();
           dartCopy.modificationTime = sourceTime;
           _cache.removedAst(unitSource);
-          _workManager.add(unitSource, WorkManagerPriority.UNKNOWN);
+          _workManager.add(unitSource, SourcePriority.UNKNOWN);
         } else {
           //
           // We could not determine whether the sources were up-to-date or out-of-date. Mark the
           // cache so that we won't attempt to re-analyze the sources until there's a good chance
           // that we'll be able to do so without error.
           //
           dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
         }
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
@@ skipping 147 matching lines @@
       logInformation("Added new source: ${debuggingString(source)}");
     } else {
       SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
       int oldTime = sourceCopy.modificationTime;
       sourceCopy.modificationTime = source.modificationStamp;
       // TODO(brianwilkerson) Understand why we're not invalidating the cache.
       _cache.put(source, sourceCopy);
       logInformation("Added new source: ${debuggingString(source)} (previously modified at ${oldTime})");
     }
     if (sourceEntry is HtmlEntry) {
-      _workManager.add(source, WorkManagerPriority.HTML);
+      _workManager.add(source, SourcePriority.HTML);
     } else {
-      _workManager.add(source, WorkManagerPriority.UNKNOWN);
+      _workManager.add(source, SourcePriority.UNKNOWN);
     }
     return sourceEntry is DartEntry;
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been changed
    */
   void sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null || sourceEntry.modificationTime == source.modificationStamp) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
       if (sourceEntry == null) {
         logInformation("Modified source, but there is no entry: ${debuggingString(source)}");
       } else {
         logInformation("Modified source, but modification time matches: ${debuggingString(source)}");
       }
       return;
     }
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
       int oldTime = htmlCopy.modificationTime;
       htmlCopy.modificationTime = source.modificationStamp;
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
       _cache.removedAst(source);
-      _workManager.add(source, WorkManagerPriority.HTML);
+      _workManager.add(source, SourcePriority.HTML);
       logInformation("Modified HTML source: ${debuggingString(source)} (previously modified at ${oldTime})");
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
         librariesToInvalidate.add(containingLibrary);
         for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
           librariesToInvalidate.add(dependentLibrary);
         }
       }
       PrintStringWriter writer = new PrintStringWriter();
       int oldTime = sourceEntry.modificationTime;
       writer.println("Modified Dart source: ${debuggingString(source)} (previously modified at ${oldTime})");
       for (Source library in librariesToInvalidate) {
         //    for (Source library : containingLibraries) {
         invalidateLibraryResolution(library, writer);
       }
       removeFromParts(source, sourceEntry);
       DartEntryImpl dartCopy = sourceEntry.writableCopy;
       dartCopy.modificationTime = source.modificationStamp;
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
       _cache.removedAst(source);
-      _workManager.add(source, WorkManagerPriority.UNKNOWN);
+      _workManager.add(source, SourcePriority.UNKNOWN);
       logInformation(writer.toString());
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void sourceRemoved(Source source) {
@@ skipping 1682 matching lines @@
 
   /**
    * Return the AST that was created from the source.
    *
    * @return the AST that was created from the source
    */
   ht.HtmlUnit get compilationUnit => data;
 }
 
 /**
+ * The enumerated type `Priority` defines the priority levels used to return sources in an
+ * optimal order.
+ */
+class SourcePriority extends Enum<SourcePriority> {
+  /**
+   * Used for a Dart source that is known to be a part contained in a library that was recently
+   * resolved. These parts are given a higher priority because there is a high probability that
+   * their AST structure is still in the cache and therefore would not need to be re-created.
+   */
+  static final SourcePriority PRIORITY_PART = new SourcePriority('PRIORITY_PART', 0);
+
+  /**
+   * Used for a Dart source that is known to be a library.
+   */
+  static final SourcePriority LIBRARY = new SourcePriority('LIBRARY', 1);
+
+  /**
+   * Used for a Dart source that is known to be a part but whose library has not yet been
+   * resolved.
+   */
+  static final SourcePriority NORMAL_PART = new SourcePriority('NORMAL_PART', 2);
+
+  /**
+   * Used for a Dart source whose kind is unknown.
+   */
+  static final SourcePriority UNKNOWN = new SourcePriority('UNKNOWN', 3);
+
+  /**
+   * Used for an HTML source.
+   */
+  static final SourcePriority HTML = new SourcePriority('HTML', 4);
+
+  static final List<SourcePriority> values = [PRIORITY_PART, LIBRARY, NORMAL_PART, UNKNOWN, HTML];
+
+  SourcePriority(String name, int ordinal) : super(name, ordinal);
+}
+
+/**
  * 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 17 matching lines @@
 class WorkManager {
   /**
    * An array containing the various queues is priority order.
    */
   List<List<Source>> _workQueues;
 
   /**
    * Initialize a newly created manager to have no work queued up.
    */
   WorkManager() {
-    int queueCount = WorkManagerPriority.values.length;
+    int queueCount = SourcePriority.values.length;
     _workQueues = new List<List>(queueCount);
     for (int i = 0; i < queueCount; i++) {
       _workQueues[i] = new List<Source>();
     }
   }
 
   /**
    * Record that the given source needs to be analyzed. The priority level is used to control when
    * the source will be analyzed with respect to other sources.
    *
    * @param source the source that needs to be analyzed
    * @param priority the priority level of the source
    */
-  void add(Source source, WorkManagerPriority priority) {
+  void add(Source source, SourcePriority priority) {
     // TODO(brianwilkerson) Optimize the order of the libraries so that libraries that depend on
     // other libraries get analyzed after the other libraries.
     int queueCount = _workQueues.length;
     int ordinal = priority.ordinal;
     for (int i = 0; i < queueCount; i++) {
       List<Source> queue = _workQueues[i];
       if (i == ordinal) {
         if (!queue.contains(source)) {
           queue.add(source);
         }
@@ skipping 26 matching lines @@
    */
   void remove(Source source) {
     int queueCount = _workQueues.length;
     for (int i = 0; i < queueCount; i++) {
       _workQueues[i].remove(source);
     }
   }
 }
 
 /**
- * The enumerated type `Priority` defines the priority levels used to return sources in an
- * optimal order.
- */
-class WorkManagerPriority extends Enum<WorkManagerPriority> {
-  /**
-   * Used for a Dart source that is known to be a part contained in a library that was recently
-   * resolved. These parts are given a higher priority because there is a high probability that
-   * their AST structure is still in the cache and therefore would not need to be re-created.
-   */
-  static final WorkManagerPriority PRIORITY_PART = new WorkManagerPriority('PRIORITY_PART', 0);
-
-  /**
-   * Used for a Dart source that is known to be a library.
-   */
-  static final WorkManagerPriority LIBRARY = new WorkManagerPriority('LIBRARY', 1);
-
-  /**
-   * Used for a Dart source that is known to be a part but whose library has not yet been
-   * resolved.
-   */
-  static final WorkManagerPriority NORMAL_PART = new WorkManagerPriority('NORMAL_PART', 2);
-
-  /**
-   * Used for a Dart source whose kind is unknown.
-   */
-  static final WorkManagerPriority UNKNOWN = new WorkManagerPriority('UNKNOWN', 3);
-
-  /**
-   * Used for an HTML source.
-   */
-  static final WorkManagerPriority HTML = new WorkManagerPriority('HTML', 4);
-
-  static final List<WorkManagerPriority> values = [PRIORITY_PART, LIBRARY, NORMAL_PART, UNKNOWN, HTML];
-
-  WorkManagerPriority(String name, int ordinal) : super(name, ordinal);
-}
-
-/**
  * An [Expression] with optional [AngularFilterNode]s.
  *
  * @coverage dart.engine.ast
  */
 class AngularExpression {
   /**
    * The [Expression] to apply filters to.
    */
   final Expression expression;
 
@@ skipping 1573 matching lines @@
 
   void internalPerform() {
     if (cache == null) {
       return;
     }
     // Only handle small changes
     if (cache.oldLength > 0 || cache.newLength > 30) {
       return;
     }
     // Produce an updated token stream
-    CharacterReader reader = new CharSequenceReader(new CharSequence(cache.newContents));
+    CharacterReader reader = new CharSequenceReader(cache.newContents);
     BooleanErrorListener errorListener = new BooleanErrorListener();
     IncrementalScanner scanner = new IncrementalScanner(cache.source, reader, errorListener);
     scanner.rescan(cache.resolvedUnit.beginToken, cache.offset, cache.oldLength, cache.newLength);
     if (errorListener.errorReported) {
       return;
     }
     // Produce an updated AST
     IncrementalParser parser = new IncrementalParser(cache.source, scanner.tokenMap, AnalysisErrorListener.NULL_LISTENER);
     _updatedUnit = parser.reparse(cache.resolvedUnit, scanner.leftToken, scanner.rightToken, cache.offset, cache.offset + cache.oldLength);
     // Update the resolution
@@ skipping 169 matching lines @@
 
 class Source_ContentReceiver_ParseDartTask_internalPerform implements Source_ContentReceiver {
   final ParseDartTask ParseDartTask_this;
 
   RecordingErrorListener errorListener;
 
   List<Token> token;
 
   Source_ContentReceiver_ParseDartTask_internalPerform(this.ParseDartTask_this, this.errorListener, this.token);
 
-  void accept(CharSequence contents, int modificationTime) {
+  void accept(String contents, int modificationTime) {
     ParseDartTask_this._modificationTime = modificationTime;
     TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
     try {
       Scanner scanner = new Scanner(ParseDartTask_this.source, new CharSequenceReader(contents), errorListener);
       scanner.preserveComments = ParseDartTask_this.context.analysisOptions.preserveComments;
       token[0] = scanner.tokenize();
       ParseDartTask_this._lineInfo = new LineInfo(scanner.lineStarts);
     } finally {
       timeCounterScan.stop();
     }
@@ skipping 854 matching lines @@
 
   void logError2(String message, Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
   void logInformation3(String message, Exception exception) {
   }
 }