Push new analyzer-experimental with Resolver and ResolverTest.

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

 // 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';
 import 'java_engine.dart';
 import 'dart:collection' show HasNextIterator;
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart' show Token, CharBufferScanner, StringScanner;
 import 'ast.dart' show CompilationUnit, Directive, PartOfDirective;
 import 'parser.dart' show Parser;
 import 'element.dart';
 import 'resolver.dart' show Namespace, NamespaceBuilder, LibraryResolver;
-import 'html_scanner.dart' show HtmlScanner, HtmlScanResult, HtmlParser, HtmlParseResult;
+import 'html.dart' show HtmlScanner, HtmlScanResult, HtmlParser, HtmlParseResult;
 
 /**
  * The unique instance of the class {@code AnalysisEngine} serves as the entry point for the
  * functionality provided by the analysis engine.
+ * @coverage dart.engine
  */
 class AnalysisEngine {
   /**
    * The suffix used for Dart source files.
    */
   static String SUFFIX_DART = "dart";
   /**
    * The short suffix used for HTML files.
    */
   static String SUFFIX_HTM = "htm";
@@ skipping 244 matching lines @@
   /**
    * Given a collection of sources with content that has changed, return an {@link Iterable}identifying the sources that need to be resolved.
    * @param changedSources an array of sources (not {@code null}, contains no {@code null}s)
    * @return An iterable returning the sources to be resolved
    */
   Iterable<Source> sourcesToResolve(List<Source> changedSources);
 }
 /**
  * Instances of the class {@code AnalysisException} represent an exception that occurred during the
  * analysis of one or more sources.
+ * @coverage dart.engine
  */
 class AnalysisException extends JavaException {
   /**
    * Initialize a newly created exception.
    */
   AnalysisException() : super() {
-    _jtd_constructor_119_impl();
+    _jtd_constructor_121_impl();
   }
-  _jtd_constructor_119_impl() {
+  _jtd_constructor_121_impl() {
   }
   /**
    * Initialize a newly created exception to have the given message.
    * @param message the message associated with the exception
    */
   AnalysisException.con1(String message) : super(message) {
-    _jtd_constructor_120_impl(message);
+    _jtd_constructor_122_impl(message);
   }
-  _jtd_constructor_120_impl(String message) {
+  _jtd_constructor_122_impl(String message) {
   }
   /**
    * Initialize a newly created exception to have the given message and cause.
    * @param message the message associated with the exception
    * @param cause the underlying exception that caused this exception
    */
   AnalysisException.con2(String message, Exception cause) : super(message, cause) {
-    _jtd_constructor_121_impl(message, cause);
+    _jtd_constructor_123_impl(message, cause);
   }
-  _jtd_constructor_121_impl(String message, Exception cause) {
+  _jtd_constructor_123_impl(String message, Exception cause) {
   }
   /**
    * Initialize a newly created exception to have the given cause.
    * @param cause the underlying exception that caused this exception
    */
   AnalysisException.con3(Exception cause) : super.withCause(cause) {
-    _jtd_constructor_122_impl(cause);
+    _jtd_constructor_124_impl(cause);
   }
-  _jtd_constructor_122_impl(Exception cause) {
+  _jtd_constructor_124_impl(Exception cause) {
   }
 }
 /**
  * Instances of {@code ChangeResult} are returned by {@link AnalysisContext#changed(ChangeSet)} to
  * indicate what operations need to be performed as a result of the change.
+ * @coverage dart.engine
  */
 class ChangeResult {
 }
 /**
  * Instances of the class {@code ChangeSet} indicate what sources have been added, changed, or
  * removed.
+ * @coverage dart.engine
  */
 class ChangeSet {
   /**
    * A table mapping the sources that have been added to their contents.
    */
   Map<Source, String> _added3 = new Map<Source, String>();
   /**
    * A table mapping the sources that have been changed to their contents.
    */
   Map<Source, String> _changed3 = new Map<Source, String>();
@@ skipping 92 matching lines @@
    */
   void removedContainer(SourceContainer container) {
     if (container != null) {
       _removedContainers.add(container);
     }
   }
 }
 /**
  * Instances of the class {@code AnalysisContextImpl} implement an {@link AnalysisContext analysis
  * context}.
+ * @coverage dart.engine
  */
 class AnalysisContextImpl implements AnalysisContext {
   /**
    * The source factory used to create the sources that can be analyzed in this context.
    */
   SourceFactory _sourceFactory;
   /**
    * A table mapping sources known to the context to the information known about the source.
    */
   Map<Source, SourceInfo> _sourceMap = new Map<Source, SourceInfo>();
@@ skipping 312 matching lines @@
   bool hasPartOfDirective(CompilationUnit unit) {
     for (Directive directive in unit.directives) {
       if (directive is PartOfDirective) {
         return true;
       }
     }
     return false;
   }
   AnalysisContextImpl_ScanResult internalScan(Source source, AnalysisErrorListener errorListener) {
     AnalysisContextImpl_ScanResult result = new AnalysisContextImpl_ScanResult();
-    Source_ContentReceiver receiver = new Source_ContentReceiver_2(source, errorListener, result);
+    Source_ContentReceiver receiver = new Source_ContentReceiver_3(source, errorListener, result);
     try {
       source.getContents(receiver);
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
     return result;
   }
   /**
    * Note: This method must only be invoked while we are synchronized on {@link #cacheLock}.
    * @param source the source that has been added
@@ skipping 54 matching lines @@
   /**
    * The line start information that was produced.
    */
   List<int> _lineStarts;
   /**
    * Initialize a newly created result object to be empty.
    */
   AnalysisContextImpl_ScanResult() : super() {
   }
 }
-class Source_ContentReceiver_2 implements Source_ContentReceiver {
+class Source_ContentReceiver_3 implements Source_ContentReceiver {
   Source source;
   AnalysisErrorListener errorListener;
   AnalysisContextImpl_ScanResult result;
-  Source_ContentReceiver_2(this.source, this.errorListener, this.result);
+  Source_ContentReceiver_3(this.source, this.errorListener, this.result);
   accept(CharBuffer contents) {
     CharBufferScanner scanner = new CharBufferScanner(source, contents, errorListener);
     result._token = scanner.tokenize();
     result._lineStarts = scanner.lineStarts;
   }
   void accept2(String contents) {
     StringScanner scanner = new StringScanner(source, contents, errorListener);
     result._token = scanner.tokenize();
     result._lineStarts = scanner.lineStarts;
   }
 }
 /**
  * Instances of the class {@code RecordingErrorListener} implement an error listener that will
  * record the errors that are reported to it in a way that is appropriate for caching those errors
  * within an analysis context.
+ * @coverage dart.engine
  */
 class RecordingErrorListener implements AnalysisErrorListener {
   /**
    * A HashMap of lists containing the errors that were collected, keyed by each {@link Source}.
    */
   Map<Source, List<AnalysisError>> _errors = new Map<Source, List<AnalysisError>>();
   /**
    * Answer the errors collected by the listener.
    * @return an array of errors (not {@code null}, contains no {@code null}s)
    */
   List<AnalysisError> get errors {
     Set<MapEntry<Source, List<AnalysisError>>> entrySet2 = getMapEntrySet(_errors);
     if (entrySet2.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
-    List<AnalysisError> resultList = new List<AnalysisError>(entrySet2.length);
+    List<AnalysisError> resultList = new List<AnalysisError>();
     for (MapEntry<Source, List<AnalysisError>> entry in entrySet2) {
       resultList.addAll(entry.getValue());
     }
     return new List.from(resultList);
   }
   /**
    * Answer the errors collected by the listener for some passed {@link Source}.
    * @param source some {@link Source} for which the caller wants the set of {@link AnalysisError}s
    * collected by this listener
    * @return the errors collected by the listener for the passed {@link Source}
@@ skipping 12 matching lines @@
     if (_errors[source9] == null) {
       errorsForSource = new List<AnalysisError>();
       _errors[source9] = errorsForSource;
     }
     errorsForSource.add(event);
   }
 }
 /**
  * Instances of the class {@code SourceInfo} maintain the information known by an analysis context
  * about an individual source.
+ * @coverage dart.engine
  */
 class SourceInfo {
   /**
    * The kind of the source.
    */
   SourceKind _kind;
   /**
    * The sources for the defining compilation units for the libraries containing the source, or{@code null} if the libraries containing the source are not yet known.
    */
   List<Source> _librarySources = null;
   SourceInfo.con1(Source source, SourceKind kind3) {
-    _jtd_constructor_151_impl(source, kind3);
+    _jtd_constructor_154_impl(source, kind3);
   }
-  _jtd_constructor_151_impl(Source source, SourceKind kind3) {
+  _jtd_constructor_154_impl(Source source, SourceKind kind3) {
     this._kind = kind3;
   }
   /**
    * Initialize a newly created information holder to hold the same information as the given holder.
    * @param info the information holder used to initialize this holder
    */
   SourceInfo.con2(SourceInfo info) {
-    _jtd_constructor_152_impl(info);
+    _jtd_constructor_155_impl(info);
   }
-  _jtd_constructor_152_impl(SourceInfo info) {
+  _jtd_constructor_155_impl(SourceInfo info) {
     _kind = info._kind;
     _librarySources = new List<Source>.from(info._librarySources);
   }
   /**
    * Add the given source to the list of sources for the defining compilation units for the
    * libraries containing this source.
    * @param source the source to be added to the list
    */
   void addLibrarySource(Source source) {
     if (_librarySources == null) {
@@ skipping 33 matching lines @@
    */
   void set kind(SourceKind kind4) {
     this._kind = kind4;
   }
 }
 /**
  * The interface {@code Logger} defines the behavior of objects that can be used to receive
  * information about errors within the analysis engine. Implementations usually write this
  * information to a file, but can also record the information for later use (such as during testing)
  * or even ignore the information.
+ * @coverage dart.engine.utilities
  */
 abstract class Logger {
   static Logger NULL = new Logger_NullLogger();
   /**
    * Log the given message as an error.
    * @param message an explanation of why the error occurred or what it means
    */
   void logError(String message);
   /**
    * Log the given exception as one representing an error.
@@ skipping 27 matching lines @@
   }
   void logError2(String message, Exception exception) {
   }
   void logError3(Exception exception) {
   }
   void logInformation(String message) {
   }
   void logInformation2(String message, Exception exception) {
   }
 }