Push new analyzer-experimental with Resolver and ResolverTest.

pkg/analyzer-experimental/lib/src/generated/source.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.source;
 
 import 'dart:uri';
 import 'java_core.dart';
 
 /**
  * Instances of the class {@code SourceFactory} resolve possibly relative URI's against an existing{@link Source source}.
+ * @coverage dart.engine.source
  */
 class SourceFactory {
   /**
    * The resolvers used to resolve absolute URI's.
    */
   List<UriResolver> _resolvers;
   /**
    * A cache of content used to override the default content of a source.
    */
   ContentCache _contentCache;
   /**
    * Initialize a newly created source factory.
    * @param contentCache the cache holding content used to override the default content of a source.
    * @param resolvers the resolvers used to resolve absolute URI's
    */
   SourceFactory.con1(ContentCache contentCache2, List<UriResolver> resolvers2) {
-    _jtd_constructor_283_impl(contentCache2, resolvers2);
+    _jtd_constructor_289_impl(contentCache2, resolvers2);
   }
-  _jtd_constructor_283_impl(ContentCache contentCache2, List<UriResolver> resolvers2) {
+  _jtd_constructor_289_impl(ContentCache contentCache2, List<UriResolver> resolvers2) {
     this._contentCache = contentCache2;
     this._resolvers = resolvers2;
   }
   /**
    * Initialize a newly created source factory.
    * @param resolvers the resolvers used to resolve absolute URI's
    */
   SourceFactory.con2(List<UriResolver> resolvers) {
-    _jtd_constructor_284_impl(resolvers);
+    _jtd_constructor_290_impl(resolvers);
   }
-  _jtd_constructor_284_impl(List<UriResolver> resolvers) {
-    _jtd_constructor_283_impl(new ContentCache(), [resolvers]);
+  _jtd_constructor_290_impl(List<UriResolver> resolvers) {
+    _jtd_constructor_289_impl(new ContentCache(), resolvers);
   }
   /**
    * Return a source object representing the given absolute URI, or {@code null} if the URI is not a
    * valid URI or if it is not an absolute URI.
    * @param absoluteUri the absolute URI to be resolved
    * @return a source object representing the absolute URI
    */
   Source forUri(String absoluteUri) {
     try {
-      Uri uri = new Uri.fromComponents(path: absoluteUri);
+      Uri uri = new Uri(absoluteUri);
       if (uri.isAbsolute) {
         return resolveUri2(null, uri);
       }
     } on URISyntaxException catch (exception) {
     }
     return null;
   }
   /**
    * Return a source object that is equal to the source object used to obtain the given encoding, or{@code null} if the argument is not a valid encoding.
    * @param encoding the encoding of a source object
@@ skipping 63 matching lines @@
       return null;
     } else {
       return containingSource.resolveRelative(containedUri);
     }
   }
 }
 /**
  * The abstract class {@code UriResolver} defines the behavior of objects that are used to resolve
  * URI's for a source factory. Subclasses of this class are expected to resolve a single scheme of
  * absolute URI.
+ * @coverage dart.engine.source
  */
 abstract class UriResolver {
   /**
    * Initialize a newly created resolver.
    */
   UriResolver() : super() {
   }
   /**
    * Resolve the given absolute URI. Return a {@link Source source} representing the file to which
    * it was resolved, or {@code null} if it could not be resolved.
    * @param uri the URI to be resolved
    * @return a {@link Source source} representing the URI to which given URI was resolved
    */
   Source resolveAbsolute(SourceFactory factory, Uri uri);
 }
 /**
  * The interface {@code Source} defines the behavior of objects representing source code that can be
  * compiled.
+ * @coverage dart.engine.source
  */
 abstract class Source {
   /**
    * An empty array of sources.
    */
   static List<Source> EMPTY_ARRAY = new List<Source>(0);
   /**
    * Return {@code true} if the given object is a source that represents the same source code as
    * this source.
    * @param object the object to be compared with this object
@@ skipping 88 matching lines @@
   accept(CharBuffer contents);
   /**
    * Accept the contents of a source represented as a string.
    * @param contents the contents of the source
    */
   void accept2(String contents);
 }
 /**
  * The enumeration {@code SourceKind} defines the different kinds of sources that are known to the
  * analysis engine.
+ * @coverage dart.engine.source
  */
 class SourceKind {
   /**
    * A source containing HTML. The HTML might or might not contain Dart scripts.
    */
   static final SourceKind HTML = new SourceKind('HTML', 0);
   /**
    * A Dart compilation unit that is not a part of another library. Libraries might or might not
    * contain any directives, including a library directive.
    */
   static final SourceKind LIBRARY = new SourceKind('LIBRARY', 1);
   /**
    * A Dart compilation unit that is part of another library. Parts contain a part-of directive.
    */
   static final SourceKind PART = new SourceKind('PART', 2);
   /**
    * An unknown kind of source. Used both when it is not possible to identify the kind of a source
    * and also when the kind of a source is not known without performing a computation and the client
    * does not want to spend the time to identify the kind.
    */
   static final SourceKind UNKNOWN = new SourceKind('UNKNOWN', 3);
   static final List<SourceKind> values = [HTML, LIBRARY, PART, UNKNOWN];
   final String __name;
   final int __ordinal;
+  int get ordinal => __ordinal;
   SourceKind(this.__name, this.__ordinal) {
   }
   String toString() => __name;
 }
 /**
  * A source range defines an {@link Element}'s source coordinates relative to its {@link Source}.
+ * @coverage dart.engine.utilities
  */
 class SourceRange {
   /**
    * The 0-based index of the first character of the source code for this element, relative to the
    * source buffer in which this element is contained.
    */
   int _offset = 0;
   /**
    * The number of characters of the source code for this element, relative to the source buffer in
    * which this element is contained.
    */
   int _length = 0;
   /**
    * Initialize a newly created source range using the given offset and the given length.
    * @param offset the given offset
    * @param length the given length
    */
   SourceRange(int offset, int length) {
     this._offset = offset;
     this._length = length;
   }
   /**
    * @return <code>true</code> if <code>x</code> is in [offset, offset + length) interval.
    */
   bool contains(int x) => _offset <= x && x < _offset + _length;
   /**
+   * @return <code>true</code> if <code>x</code> is in (offset, offset + length) interval.
+   */
+  bool containsExclusive(int x) => _offset < x && x < _offset + _length;
+  /**
    * @return <code>true</code> if <code>otherRange</code> covers this {@link SourceRange}.
    */
   bool coveredBy(SourceRange otherRange) => otherRange.covers(this);
   /**
    * @return <code>true</code> if this {@link SourceRange} covers <code>otherRange</code>.
    */
   bool covers(SourceRange otherRange) => offset <= otherRange.offset && otherRange.end <= end;
   /**
    * @return <code>true</code> if this {@link SourceRange} ends in <code>otherRange</code>.
    */
@@ skipping 65 matching lines @@
     return builder.toString();
   }
 }
 /**
  * The interface {@code SourceContainer} is used by clients to define a collection of sources
  * <p>
  * Source containers are not used within analysis engine, but can be used by clients to group
  * sources for the purposes of accessing composite dependency information. For example, the Eclipse
  * client uses source containers to represent Eclipse projects, which allows it to easily compute
  * project-level dependencies.
+ * @coverage dart.engine.source
  */
 abstract class SourceContainer {
   /**
    * Determine if the specified source is part of the receiver's collection of sources.
    * @param source the source in question
    * @return {@code true} if the receiver contains the source, else {@code false}
    */
   bool contains(Source source);
 }
 /**
  * Instances of the class {@code LineInfo} encapsulate information about line and column information
  * within a source file.
+ * @coverage dart.engine.utilities
  */
 class LineInfo {
   /**
    * An array containing the offsets of the first character of each line in the source code.
    */
   List<int> _lineStarts;
   /**
    * Initialize a newly created set of line information to represent the data encoded in the given
    * array.
    * @param lineStarts the offsets of the first character of each line in the source code
@@ skipping 50 matching lines @@
    */
   int get columnNumber => _columnNumber;
   /**
    * Return the one-based index of the line containing the character.
    * @return the one-based index of the line containing the character
    */
   int get lineNumber => _lineNumber;
 }
 /**
  * Instances of class {@code ContentCache} hold content used to override the default content of a{@link Source}.
+ * @coverage dart.engine.source
  */
 class ContentCache {
   /**
    * A table mapping sources to the contents of those sources. This is used to override the default
    * contents of a source.
    */
   Map<Source, String> _contentMap = new Map<Source, String>();
   /**
    * A table mapping sources to the modification stamps of those sources. This is used when the
    * default contents of a source has been overridden.
@@ skipping 32 matching lines @@
   void setContents(Source source, String contents) {
     if (contents == null) {
       _contentMap.remove(source);
       _stampMap.remove(source);
     } else {
       _contentMap[source] = contents;
       _stampMap[source] = JavaSystem.currentTimeMillis();
     }
   }
 }