Breaking changes in 'analyzer' package.

pkg/analyzer/lib/src/generated/source.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.source;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'sdk.dart' show DartSdk;
-import 'engine.dart' show AnalysisContext, TimestampedData;
+import 'engine.dart';
+import 'java_engine.dart';
 
 /**
  * Instances of class `ContentCache` hold content used to override the default content of a
  * [Source].
  */
 class ContentCache {
   /**
    * A table mapping sources to the contents of those sources. This is used to override the default
    * contents of a source.
    */
@@ skipping 68 matching lines @@
   static bool isDartExtUri(String uriContent) => uriContent != null && uriContent.startsWith(_DART_EXT_SCHEME);
 
   /**
    * The Dart SDK against which URI's are to be resolved.
    */
   final DartSdk _sdk;
 
   /**
    * The name of the `dart` scheme.
    */
-  static String _DART_SCHEME = "dart";
+  static String DART_SCHEME = "dart";
 
   /**
    * The prefix of a URI using the dart-ext scheme to reference a native code library.
    */
   static String _DART_EXT_SCHEME = "dart-ext:";
 
   /**
    * Return `true` if the given URI is a `dart:` URI.
    *
    * @param uri the URI being tested
    * @return `true` if the given URI is a `dart:` URI
    */
-  static bool isDartUri(Uri uri) => _DART_SCHEME == uri.scheme;
+  static bool isDartUri(Uri uri) => DART_SCHEME == uri.scheme;
 
   /**
    * Initialize a newly created resolver to resolve Dart URI's against the given platform within the
    * given Dart SDK.
    *
    * @param sdk the Dart SDK against which URI's are to be resolved
    */
   DartUriResolver(this._sdk);
 
-  @override
-  Source fromEncoding(UriKind kind, Uri uri) {
-    if (kind == UriKind.DART_URI) {
-      return _sdk.fromEncoding(kind, uri);
-    }
-    return null;
-  }
-
   /**
    * Return the [DartSdk] against which URIs are to be resolved.
    *
    * @return the [DartSdk] against which URIs are to be resolved.
    */
   DartSdk get dartSdk => _sdk;
 
   @override
   Source resolveAbsolute(Uri uri) {
     if (!isDartUri(uri)) {
@@ skipping 149 matching lines @@
   @override
   String get fullName => _name;
 
   @override
   int get modificationStamp => 0;
 
   @override
   String get shortName => _name;
 
   @override
+  Uri get uri => null;
+
+  @override
   int get hashCode => _name.hashCode;
 
   @override
   bool get isInSystemLibrary => false;
 
   @override
-  Source resolveRelative(Uri relativeUri) {
+  Uri resolveRelativeUri(Uri relativeUri) {
     throw new UnsupportedOperationException("${_name}does not exist.");
   }
 }
 
 /**
  * The interface `Source` defines the behavior of objects representing source code that can be
  * analyzed by the analysis engine.
  *
  * Implementations of this interface need to be aware of some assumptions made by the analysis
  * engine concerning sources:
@@ skipping 87 matching lines @@
 
   /**
    * Return a short version of the name that can be displayed to the user to denote this source. For
    * example, for a source representing a file this would typically be the name of the file.
    *
    * @return a name that can be displayed to the user to denote this source
    */
   String get shortName;
 
   /**
+   * Return the URI from which this source was originally derived.
+   *
+   * @return the URI from which this source was originally derived
+   */
+  Uri get uri;
+
+  /**
    * Return the kind of URI from which this source was originally derived. If this source was
    * created from an absolute URI, then the returned kind will reflect the scheme of the absolute
    * URI. If it was created from a relative URI, then the returned kind will be the same as the kind
    * of the source against which the relative URI was resolved.
    *
    * @return the kind of URI from which this source was originally derived
    */
   UriKind get uriKind;
 
   /**
    * Return a hash code for this source.
    *
    * @return a hash code for this source
    * @see Object#hashCode()
    */
   @override
   int get hashCode;
 
   /**
    * Return `true` if this source is in one of the system libraries.
    *
    * @return `true` if this is in a system library
    */
   bool get isInSystemLibrary;
 
   /**
-   * Resolve the relative URI against the URI associated with this source object. Return a
-   * [Source] representing the URI to which it was resolved, or `null` if it
-   * could not be resolved.
+   * Resolve the relative URI against the URI associated with this source object.
    *
    * Note: This method is not intended for public use, it is only visible out of necessity. It is
    * only intended to be invoked by a [SourceFactory]. Source factories will
    * only invoke this method if the URI is relative, so implementations of this method are not
    * required to, and generally do not, verify the argument. The result of invoking this method with
    * an absolute URI is intentionally left unspecified.
    *
-   * @param relativeUri the relative URI to be resolved against the containing source
-   * @return a [Source] representing the URI to which given URI was resolved
+   * @param relativeUri the relative URI to be resolved against this source
+   * @return the URI to which given URI was resolved
+   * @throws AnalysisException if the relative URI could not be resolved
    */
-  Source resolveRelative(Uri relativeUri);
+  Uri resolveRelativeUri(Uri relativeUri);
 }
 
 /**
  * The interface `SourceContainer` is used by clients to define a collection of sources
  *
  * 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.
  */
@@ skipping 40 matching lines @@
    *
    * @param absoluteUri the absolute URI to be resolved
    * @return a source object representing the absolute URI
    */
   Source forUri(String absoluteUri) {
     try {
       Uri uri = parseUriWithException(absoluteUri);
       if (uri.isAbsolute) {
         return _internalResolveUri(null, uri);
       }
-    } on URISyntaxException catch (exception) {
+    } catch (exception) {
+      AnalysisEngine.instance.logger.logError2("Could not resolve URI: ${absoluteUri}", exception);
     }
     return null;
   }
+
+  /**
+   * Return a source object representing the given absolute URI, or `null` if the URI is not
+   * an absolute URI.
+   *
+   * @param absoluteUri the absolute URI to be resolved
+   * @return a source object representing the absolute URI
+   */
+  Source forUri2(Uri absoluteUri) {
+    if (absoluteUri.isAbsolute) {
+      try {
+        return _internalResolveUri(null, absoluteUri);
+      } on AnalysisException catch (exception, stackTrace) {
+        AnalysisEngine.instance.logger.logError2("Could not resolve URI: ${absoluteUri}", new CaughtException(exception, stackTrace));
+      }
+    }
+    return null;
+  }
 
   /**
    * Return a source object that is equal to the source object used to obtain the given encoding.
    *
    * @param encoding the encoding of a source object
    * @return a source object that is described by the given encoding
    * @throws IllegalArgumentException if the argument is not a valid encoding
    * @see Source#getEncoding()
    */
   Source fromEncoding(String encoding) {
-    if (encoding.length < 2) {
-      throw new IllegalArgumentException("Invalid encoding length");
+    Source source = forUri(encoding);
+    if (source == null) {
+      throw new IllegalArgumentException("Invalid source encoding: ${encoding}");
     }
-    UriKind kind = UriKind.fromEncoding(encoding.codeUnitAt(0));
-    if (kind == null) {
-      throw new IllegalArgumentException("Invalid source kind in encoding: ${kind}");
-    }
-    try {
-      Uri uri = parseUriWithException(encoding.substring(1));
-      for (UriResolver resolver in _resolvers) {
-        Source result = resolver.fromEncoding(kind, uri);
-        if (result != null) {
-          return result;
-        }
-      }
-      throw new IllegalArgumentException("No resolver for kind: ${kind}");
-    } catch (exception) {
-      throw new IllegalArgumentException("Invalid URI in encoding");
-    }
+    return source;
   }
 
   /**
    * Return the [DartSdk] associated with this [SourceFactory], or `null` if there
    * is no such SDK.
    *
    * @return the [DartSdk] associated with this [SourceFactory], or `null` if
    *         there is no such SDK
    */
   DartSdk get dartSdk {
@@ skipping 24 matching lines @@
    * @param containedUri the (possibly relative) URI to be resolved against the containing source
    * @return the source representing the contained URI
    */
   Source resolveUri(Source containingSource, String containedUri) {
     if (containedUri == null || containedUri.isEmpty) {
       return null;
     }
     try {
       // Force the creation of an escaped URI to deal with spaces, etc.
       return _internalResolveUri(containingSource, parseUriWithException(containedUri));
-    } on URISyntaxException catch (exception) {
+    } catch (exception) {
+      AnalysisEngine.instance.logger.logError2("Could not resolve URI (${containedUri}) relative to source (${containingSource.fullName})", exception);
       return null;
     }
   }
 
   /**
    * Return an absolute URI that represents the given source, or `null` if a valid URI cannot
    * be computed.
    *
    * @param source the source to get URI for
    * @return the absolute URI representing the given source
@@ skipping 13 matching lines @@
    *
    * @param localSourcePredicate the predicate to determine is [Source] is local
    */
   void set localSourcePredicate(LocalSourcePredicate localSourcePredicate) {
     this._localSourcePredicate = localSourcePredicate;
   }
 
   /**
    * Return a source object representing the URI that results from resolving the given (possibly
    * relative) contained URI against the URI associated with an existing source object, or
-   * `null` if either the contained URI is invalid or if it cannot be resolved against the
-   * source object's URI.
+   * `null` if the URI could not be resolved.
    *
    * @param containingSource the source containing the given URI
    * @param containedUri the (possibly relative) URI to be resolved against the containing source
    * @return the source representing the contained URI
+   * @throws AnalysisException if either the contained URI is invalid or if it cannot be resolved
+   *           against the source object's URI
    */
   Source _internalResolveUri(Source containingSource, Uri containedUri) {
-    if (containedUri.isAbsolute) {
-      for (UriResolver resolver in _resolvers) {
-        Source result = resolver.resolveAbsolute(containedUri);
-        if (result != null) {
-          return result;
-        }
+    if (!containedUri.isAbsolute) {
+      if (containingSource == null) {
+        throw new AnalysisException("Cannot resolve a relative URI without a containing source: ${containedUri}");
       }
-      return null;
-    } else {
-      return containingSource.resolveRelative(containedUri);
+      containedUri = containingSource.resolveRelativeUri(containedUri);
     }
+    for (UriResolver resolver in _resolvers) {
+      Source result = resolver.resolveAbsolute(containedUri);
+      if (result != null) {
+        return result;
+      }
+    }
+    return null;
   }
 }
 
 /**
  * The enumeration `SourceKind` defines the different kinds of sources that are known to the
  * analysis engine.
  */
 class SourceKind extends Enum<SourceKind> {
   /**
    * A source containing HTML. The HTML might or might not contain Dart scripts.
@@ skipping 225 matching lines @@
   const UriKind(String name, int ordinal, this.encoding) : super(name, ordinal);
 }
 
 /**
  * The abstract class `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.
  */
 abstract class UriResolver {
   /**
-   * If this resolver should be used for URI's of the given kind, resolve the given absolute URI.
-   * The URI does not need to have the scheme handled by this resolver if the kind matches. Return a
-   * [Source] representing the file to which it was resolved, whether or not the
-   * resulting source exists, or `null` if it could not be resolved because the URI is
-   * invalid.
-   *
-   * @param kind the kind of URI that was originally resolved in order to produce an encoding with
-   *          the given URI
-   * @param uri the URI to be resolved
-   * @return a [Source] representing the file to which given URI was resolved
-   */
-  Source fromEncoding(UriKind kind, Uri uri);
-
-  /**
    * Resolve the given absolute URI. Return a [Source] representing the file to which
    * it was resolved, whether or not the resulting source exists, or `null` if it could not be
    * resolved because the URI is invalid.
    *
    * @param uri the URI to be resolved
    * @return a [Source] representing the file to which given URI was resolved
    */
   Source resolveAbsolute(Uri uri);
 
   /**
    * Return an absolute URI that represents the given source, or `null` if a valid URI cannot
    * be computed.
    *
    * @param source the source to get URI for
    * @return the absolute URI representing the given source
    */
   Uri restoreAbsolute(Source source) => null;
 }