Uncomment and clean up engine_test.dart

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 980 matching lines @@
 
   /**
    * 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() {
+  AnalysisContextImpl() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _privatePartition = new UniversalCachePartition(this, AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
     _cache = createCacheFromSourceFactory(null);
   }
 
+  IncrementalAnalysisCache get test_incrementalAnalysisCache {

[Brian Wilkerson, 2014/10/05 17:54:37]

I really dislike having methods that exist only for testing be prefixed with
"test_". To my JUnit trained eye this makes them look like test methods. I don't
like having these methods at all, but I don't know of a reasonable alternative.
(No, this comment isn't particularly actionable, I'm just complaining...)

[scheglov, 2014/10/05 19:55:36]

  These methods are used instead of using reflection in Java.
  You're welcome to rename them later :-)

+    return _incrementalAnalysisCache;
+  }
+
+  set test_incrementalAnalysisCache(IncrementalAnalysisCache value) {
+    _incrementalAnalysisCache = value;
+  }
+
+  List<Source> get test_priorityOrder => _priorityOrder;
+
   @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
@@ skipping 376 matching lines @@
   }
 
   @override
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
       return Source.EMPTY_ARRAY;
     }
     List<Source> htmlSources = new List<Source>();
     while (true) {
-      if (sourceKind == SourceKind.LIBRARY) {
-      } else if (sourceKind == SourceKind.PART) {
+      if (sourceKind == SourceKind.PART) {
         List<Source> librarySources = getLibrariesContaining(source);
         MapIterator<Source, SourceEntry> partIterator = _cache.iterator();
         while (partIterator.moveNext()) {
           SourceEntry sourceEntry = partIterator.value;
           if (sourceEntry.kind == SourceKind.HTML) {
             List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_containsAny(referencedLibraries, librarySources)) {
               htmlSources.add(partIterator.key);
             }
           }
         }
+      } else {
+        MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+        while (iterator.moveNext()) {
+          SourceEntry sourceEntry = iterator.value;
+          if (sourceEntry.kind == SourceKind.HTML) {
+            List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
+            if (_contains(referencedLibraries, source)) {
+              htmlSources.add(iterator.key);
+            }
+          }
+        }
       }
       break;
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(htmlSources);
   }
 
   @override
@@ skipping 11757 matching lines @@
     }
   }
 
   /**
    * Return the sources of libraries that are referenced in the specified HTML file.
    *
    * @return the sources of libraries that are referenced in the HTML file
    */
   List<Source> get librarySources {
     List<Source> libraries = new List<Source>();
-    _unit.accept(new RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources(this, libraries));
+    _unit.accept(new ParseHtmlTask_getLibrarySources(this, libraries));
     if (libraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
-    return new List.from(libraries);
+    return libraries;
   }
 
   /**
    * Resolves directives in the given [CompilationUnit].
    */
   void _resolveScriptDirectives(CompilationUnit script, AnalysisErrorListener errorListener) {
     if (script == null) {
       return;
     }
     AnalysisContext analysisContext = context;
@@ skipping 694 matching lines @@
   @override
   Object visitXmlTagNode(ht.XmlTagNode node) {
     NgModelProcessor directive = NgModelProcessor.INSTANCE;
     if (directive.canApply(node)) {
       directive._applyTopDeclarations(AngularHtmlUnitResolver_this, node);
     }
     return super.visitXmlTagNode(node);
   }
 }
 
-class RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources extends ht.RecursiveXmlVisitor<Object> {
-  final ParseHtmlTask ParseHtmlTask_this;
+class ParseHtmlTask_getLibrarySources extends ht.RecursiveXmlVisitor<Object> {
+  final ParseHtmlTask _task;
 
   List<Source> libraries;
 
-  RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources(this.ParseHtmlTask_this, this.libraries) : super();
+  ParseHtmlTask_getLibrarySources(this._task, this.libraries) : super();
 
   @override
   Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     ht.XmlAttributeNode scriptAttribute = null;
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (javaStringEqualsIgnoreCase(attribute.name, ParseHtmlTask._ATTRIBUTE_SRC)) {
         scriptAttribute = attribute;
       }
     }
     if (scriptAttribute != null) {
       try {
         Uri uri = new Uri(path: scriptAttribute.text);
         String fileName = uri.path;
-        Source librarySource = ParseHtmlTask_this.context.sourceFactory.resolveUri(ParseHtmlTask_this.source, fileName);
-        if (ParseHtmlTask_this.context.exists(librarySource)) {
+        Source librarySource = _task.context.sourceFactory.resolveUri(_task.source, fileName);
+        if (_task.context.exists(librarySource)) {
           libraries.add(librarySource);
         }
-      } on URISyntaxException catch (e) {
+      } on FormatException catch (e) {
       }
     }
     return super.visitHtmlScriptTagNode(node);
   }
 }
 
 class RecursiveXmlVisitor_ParseHtmlTask_internalPerform extends ht.RecursiveXmlVisitor<Object> {
   final ParseHtmlTask ParseHtmlTask_this;
 
   RecordingErrorListener errorListener;
@@ skipping 1600 matching lines @@
     }
     return builder.toString();
   }
 }
 
 /**
  * Instances of the class `WorkIterator` implement an iterator that returns the sources in a
  * work manager in the order in which they are to be analyzed.
  */
 class WorkManager_WorkIterator {
-  final WorkManager WorkManager_this;
+  final WorkManager _manager;
 
   /**
    * The index of the work queue through which we are currently iterating.
    */
   int _queueIndex = 0;
 
   /**
    * The index of the next element of the work queue to be returned.
    */
   int _index = -1;
 
   /**
    * Initialize a newly created iterator to be ready to return the first element in the iteration.
    */
-  WorkManager_WorkIterator(this.WorkManager_this) {
+  WorkManager_WorkIterator(this._manager) {
     _advance();
   }
 
   /**
    * Return `true` if there is another [Source] available for processing.
    *
    * @return `true` if there is another [Source] available for processing
    */
-  bool get hasNext => _queueIndex < WorkManager_this._workQueues.length;
+  bool get hasNext => _queueIndex < _manager._workQueues.length;
 
   /**
    * Return the next [Source] available for processing and advance so that the returned
    * source will not be returned again.
    *
    * @return the next [Source] available for processing
    */
   Source next() {
     if (!hasNext) {
       throw new NoSuchElementException();
     }
-    Source source = WorkManager_this._workQueues[_queueIndex][_index];
+    Source source = _manager._workQueues[_queueIndex][_index];
     _advance();
     return source;
   }
 
   /**
    * Increment the [index] and [queueIndex] so that they are either indicating the
    * next source to be returned or are indicating that there are no more sources to be returned.
    */
   void _advance() {
     _index++;
-    if (_index >= WorkManager_this._workQueues[_queueIndex].length) {
+    if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
-      while (_queueIndex < WorkManager_this._workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
+      while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }