Fix for translation of \!= to \!identical(), but use == and \!= for Enum.

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 'java_core.dart';
@@ skipping 51 matching lines @@
  */
 class SourceFactory {
   /**
    * The analysis context that this source factory is associated with.
    */
   AnalysisContext context;
 
   /**
    * The resolvers used to resolve absolute URI's.
    */
-  List<UriResolver> _resolvers;
+  final List<UriResolver> _resolvers;
 
   /**
    * The predicate to determine is [Source] is local.
    */
   LocalSourcePredicate _localSourcePredicate = LocalSourcePredicate.NOT_SDK;
 
   /**
    * Initialize a newly created source factory.
    *
    * @param resolvers the resolvers used to resolve absolute URI's
    */
-  SourceFactory(List<UriResolver> resolvers) {
-    this._resolvers = resolvers;
-  }
+  SourceFactory(this._resolvers);
 
   /**
    * Return a source object representing the given absolute URI, or `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 {
@@ skipping 56 matching lines @@
   /**
    * Determines if the given [Source] is local.
    *
    * @param source the [Source] to analyze
    * @return `true` if the given [Source] is local
    */
   bool isLocalSource(Source source) => _localSourcePredicate.isLocal(source);
 
   /**
    * 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.
+   * relative) contained URI against the URI associated with an existing source object, whether or
+   * not the resulting source exists, or `null` if either the contained URI is invalid or if
+   * it cannot be resolved against the source object's URI.
    *
    * @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
    */
   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) {
       return null;
     }
   }
 
   /**
-   * Return an absolute URI that represents the given source.
+   * 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, may be `null`
+   * @return the absolute URI representing the given source
    */
   Uri restoreUri(Source source) {
     for (UriResolver resolver in _resolvers) {
       Uri uri = resolver.restoreAbsolute(source);
       if (uri != null) {
         return uri;
       }
     }
     return null;
   }
@@ skipping 34 matching lines @@
 
 /**
  * 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, or `null` if it
-   * could not be resolved.
+   * [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, or `null` if it could not be resolved.
+   * 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.
+   * 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, may be `null`
+   * @return the absolute URI representing the given source
    */
   Uri restoreAbsolute(Source source) => null;
 }
 
 /**
  * The interface `Source` defines the behavior of objects representing source code that can be
- * compiled.
+ * analyzed by the analysis engine.
+ *
+ * Implementations of this interface need to be aware of some assumptions made by the analysis
+ * engine concerning sources:
+ * * Sources are not required to be unique. That is, there can be multiple instances representing
+ * the same source.
+ * * Sources are long lived. That is, the engine is allowed to hold on to a source for an extended
+ * period of time and that source must continue to report accurate and up-to-date information.
+ * Because of these assumptions, most implementations will not maintain any state but will delegate
+ * to an authoritative system of record in order to implement this API. For example, a source that
+ * represents files on disk would typically query the file system to determine the state of the
+ * file.
+ *
+ * If the instances that implement this API are the system of record, then they will typically be
+ * unique. In that case, sources that are created that represent non-existent files must also be
+ * retained so that if those files are created at a later date the long-lived sources representing
+ * those files will know that they now exist.
  */
 abstract class Source {
   /**
    * An empty array of sources.
    */
   static final List<Source> EMPTY_ARRAY = new List<Source>(0);
 
   /**
    * Return `true` if the given object is a source that represents the same source code as
    * this source.
@@ skipping 128 matching lines @@
 }
 
 /**
  * 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.
    */
-  static final SourceKind HTML = new SourceKind('HTML', 0);
+  static const SourceKind HTML = const 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);
+  static const SourceKind LIBRARY = const 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);
+  static const SourceKind PART = const 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 const SourceKind UNKNOWN = const SourceKind('UNKNOWN', 3);
 
-  static final List<SourceKind> values = [HTML, LIBRARY, PART, UNKNOWN];
+  static const List<SourceKind> values = const [HTML, LIBRARY, PART, UNKNOWN];
 
-  SourceKind(String name, int ordinal) : super(name, ordinal);
+  const SourceKind(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * The enumeration `UriKind` defines the different kinds of URI's that are known to the
  * analysis engine. These are used to keep track of the kind of URI associated with a given source.
  */
 class UriKind extends Enum<UriKind> {
   /**
    * A 'dart:' URI.
    */
-  static final UriKind DART_URI = new UriKind('DART_URI', 0, 0x64);
+  static const UriKind DART_URI = const UriKind('DART_URI', 0, 0x64);
 
   /**
    * A 'file:' URI.
    */
-  static final UriKind FILE_URI = new UriKind('FILE_URI', 1, 0x66);
+  static const UriKind FILE_URI = const UriKind('FILE_URI', 1, 0x66);
 
   /**
    * A 'package:' URI referencing source package itself.
    */
-  static final UriKind PACKAGE_SELF_URI = new UriKind('PACKAGE_SELF_URI', 2, 0x73);
+  static const UriKind PACKAGE_SELF_URI = const UriKind('PACKAGE_SELF_URI', 2, 0x73);
 
   /**
    * A 'package:' URI.
    */
-  static final UriKind PACKAGE_URI = new UriKind('PACKAGE_URI', 3, 0x70);
+  static const UriKind PACKAGE_URI = const UriKind('PACKAGE_URI', 3, 0x70);
 
-  static final List<UriKind> values = [DART_URI, FILE_URI, PACKAGE_SELF_URI, PACKAGE_URI];
+  static const List<UriKind> values = const [DART_URI, FILE_URI, PACKAGE_SELF_URI, PACKAGE_URI];
 
   /**
    * Return the URI kind represented by the given encoding, or `null` if there is no kind with
    * the given encoding.
    *
    * @param encoding the single character encoding used to identify the URI kind to be returned
    * @return the URI kind represented by the given encoding
    */
   static UriKind fromEncoding(int encoding) {
     while (true) {
       if (encoding == 0x64) {
         return DART_URI;
       } else if (encoding == 0x66) {
         return FILE_URI;
       } else if (encoding == 0x73) {
         return PACKAGE_SELF_URI;
       } else if (encoding == 0x70) {
         return PACKAGE_URI;
       }
       break;
     }
     return null;
   }
 
   /**
    * The single character encoding used to identify this kind of URI.
    */
-  int encoding = 0;
+  final int encoding;
 
   /**
    * Initialize a newly created URI kind to have the given encoding.
    *
    * @param encoding the single character encoding used to identify this kind of URI.
    */
-  UriKind(String name, int ordinal, int encoding) : super(name, ordinal) {
-    this.encoding = encoding;
-  }
+  const UriKind(String name, int ordinal, this.encoding) : super(name, ordinal);
 }
 
 /**
  * A source range defines an [Element]'s source coordinates relative to its [Source].
  */
 class SourceRange {
   /**
    * An empty [SourceRange] with offset `0` and length `0`.
    */
   static SourceRange EMPTY = new SourceRange(0, 0);
 
   /**
    * 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;
+  final int offset;
 
   /**
    * 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;
+  final int length;
 
   /**
    * 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;
-  }
+  SourceRange(this.offset, this.length);
 
   /**
    * @return `true` if <code>x</code> is in [offset, offset + length) interval.
    */
   bool contains(int x) => offset <= x && x < offset + length;
 
   /**
    * @return `true` if <code>x</code> is in (offset, offset + length) interval.
    */
   bool containsExclusive(int x) => offset < x && x < offset + length;
@@ skipping 98 matching lines @@
    * @return `true` if the receiver contains the source, else `false`
    */
   bool contains(Source source);
 }
 
 /**
  * Instances of the class `DartUriResolver` resolve `dart` URI's.
  */
 class DartUriResolver extends UriResolver {
   /**
+   * Return `true` if the given URI is a `dart-ext:` URI.
+   *
+   * @param uriContent the textual representation of the URI being tested
+   * @return `true` if the given URI is a `dart-ext:` URI
+   */
+  static bool isDartExtUri(String uriContent) => uriContent != null && uriContent.startsWith(_DART_EXT_SCHEME);
+
+  /**
    * The Dart SDK against which URI's are to be resolved.
    */
-  DartSdk _sdk;
+  final DartSdk _sdk;
 
   /**
    * The name of the `dart` scheme.
    */
   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;
 
   /**
    * 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(DartSdk sdk) {
-    this._sdk = sdk;
-  }
+  DartUriResolver(this._sdk);
 
   @override
   Source fromEncoding(UriKind kind, Uri uri) {
-    if (identical(kind, UriKind.DART_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)) {
       return null;
     }
     return _sdk.mapDartUri(uri.toString());
   }
 }
 
 /**
  * Instances of the class `LineInfo` encapsulate information about line and column information
  * within a source file.
  */
 class LineInfo {
   /**
    * An array containing the offsets of the first character of each line in the source code.
    */
-  List<int> _lineStarts;
+  final 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
    */
-  LineInfo(List<int> lineStarts) {
-    if (lineStarts == null) {
+  LineInfo(this._lineStarts) {
+    if (_lineStarts == null) {
       throw new IllegalArgumentException("lineStarts must be non-null");
-    } else if (lineStarts.length < 1) {
+    } else if (_lineStarts.length < 1) {
       throw new IllegalArgumentException("lineStarts must be non-empty");
     }
-    this._lineStarts = lineStarts;
   }
 
   /**
    * Return the location information for the character at the given offset.
    *
    * @param offset the offset of the character for which location information is to be returned
    * @return the location information for the character at the given offset
    */
   LineInfo_Location getLocation(int offset) {
     int lineCount = _lineStarts.length;
     for (int i = 1; i < lineCount; i++) {
       if (offset < _lineStarts[i]) {
         return new LineInfo_Location(i, offset - _lineStarts[i - 1] + 1);
       }
     }
     return new LineInfo_Location(lineCount, offset - _lineStarts[lineCount - 1] + 1);
   }
 }
 
 /**
  * Instances of the class `Location` represent the location of a character as a line and
  * column pair.
  */
 class LineInfo_Location {
   /**
    * The one-based index of the line containing the character.
    */
-  int lineNumber = 0;
+  final int lineNumber;
 
   /**
    * The one-based index of the column containing the character.
    */
-  int columnNumber = 0;
+  final int columnNumber;
 
   /**
    * Initialize a newly created location to represent the location of the character at the given
    * line and column position.
    *
    * @param lineNumber the one-based index of the line containing the character
    * @param columnNumber the one-based index of the column containing the character
    */
-  LineInfo_Location(int lineNumber, int columnNumber) {
-    this.lineNumber = lineNumber;
-    this.columnNumber = columnNumber;
-  }
+  LineInfo_Location(this.lineNumber, this.columnNumber);
 }
 
 /**
  * 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 48 matching lines @@
       int oldStamp = javaMapPut(_stampMap, source, newStamp);
       // Occasionally, if this method is called in rapid succession, the timestamps are equal.
       // Guard against this by artificially incrementing the new timestamp
       if (newStamp == oldStamp) {
         _stampMap[source] = newStamp + 1;
       }
       return javaMapPut(_contentMap, source, contents);
     }
   }
 }