New analyzer snapshot.

pkg/code_transformers/lib/src/resolver_impl.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.
 
 library code_transformer.src.resolver_impl;
 
 import 'dart:async';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 51 matching lines @@
       options = new AnalysisOptionsImpl()
         ..cacheSize = 256 // # of sources to cache ASTs for.
         ..preserveComments = false
         ..analyzeFunctionBodies = true;
     }
     _context.analysisOptions = options;
 
     _dartSdk = new _DirectoryBasedDartSdkProxy(new JavaFile(sdkDir));
     _dartSdk.context.analysisOptions = options;
 
-    _context.sourceFactory = new SourceFactory.con2([
+    _context.sourceFactory = new SourceFactory([
         new DartUriResolverProxy(_dartSdk),
         new _AssetUriResolver(this)]);
   }
 
   LibraryElement get entryLibrary => _entryLibrary;
 
   Future<Resolver> resolve(Transform transform) {
     // Can only have one resolve in progress at a time, so chain the current
     // resolution to be after the last one.
     var phaseComplete = new Completer();
@@ skipping 151 matching lines @@
   TextEditTransaction createTextEditTransaction(Element element) {
     if (element.source is! _AssetBasedSource) return null;
 
     _AssetBasedSource source = element.source;
     // Cannot modify assets in other packages.
     if (source.assetId.package != entryPoint.package) return null;
 
     var sourceFile = _getSourceFile(element);
     if (sourceFile == null) return null;
 
-    return new TextEditTransaction(source.contents, sourceFile);
+    return new TextEditTransaction(source.rawContents, sourceFile);
   }
 
   /// Gets the SourceFile for the source of the element.
   SourceFile _getSourceFile(Element element) {
     var assetId = getSourceAssetId(element);
     if (assetId == null) return null;
 
     var importUri = _getSourceUri(element, from: entryPoint);
     var spanPath = importUri != null ? importUri.toString() : assetId.path;
-    return new SourceFile.text(spanPath, sources[assetId].contents);
+    return new SourceFile.text(spanPath, sources[assetId].rawContents);
   }
 }
 
 /// Implementation of Analyzer's Source for Barback based assets.
 class _AssetBasedSource extends Source {
 
   /// Asset ID where this source can be found.
   final AssetId assetId;
 
   /// The resolver this is being used in.
@@ skipping 31 matching lines @@
     _dependentAssets = compilationUnit.directives
         .where((d) => (d is ImportDirective || d is PartDirective ||
             d is ExportDirective))
         .map((d) => _resolve(assetId, d.uri.stringValue,
             _logger, _getSpan(d)))
         .where((id) => id != null).toSet();
     return true;
   }
 
   /// Contents of the file.
-  String get contents => _contents;
+  TimestampedData<String> get contents =>
+      new TimestampedData<String>(modificationStamp, _contents);
+
+  /// Contents of the file.
+  String get rawContents => _contents;
 
   /// Logger for the current transform.
   ///
   /// Only valid while the resolver is updating assets.
   TransformLogger get _logger => _resolver._currentTransform.logger;
 
   /// Gets all imports/parts/exports which resolve to assets (non-Dart files).
   Iterable<AssetId> get dependentAssets => _dependentAssets;
 
   bool exists() => true;
 
   bool operator ==(Object other) =>
       other is _AssetBasedSource && assetId == other.assetId;
 
   int get hashCode => assetId.hashCode;
 
-  void getContents(Source_ContentReceiver receiver) {
-    receiver.accept(contents, modificationStamp);
+  void getContentsToReceiver(Source_ContentReceiver receiver) {
+    receiver.accept(rawContents, modificationStamp);
   }
 
   String get encoding =>
       "${uriKind.encoding}${assetId.package}/${assetId.path}";
 
   String get fullName => assetId.toString();
 
   int get modificationStamp => _revision;
 
   String get shortName => path.basename(assetId.path);
@@ skipping 17 matching lines @@
     return source;
   }
 
   /// For logging errors.
   Span _getSpan(ASTNode node) => _sourceFile.span(node.offset, node.end);
   /// For logging errors.
   SourceFile get _sourceFile {
     var uri = getSourceUri(_resolver.entryPoint);
     var path = uri != null ? uri.toString() : assetId.path;
 
-    return new SourceFile.text(path, contents);
+    return new SourceFile.text(path, rawContents);
   }
 
   /// Gets a URI which would be appropriate for importing this file.
   ///
   /// Note that this file may represent a non-importable file such as a part.
   Uri getSourceUri([AssetId from]) {
     if (!assetId.path.startsWith('lib/')) {
       // Cannot do absolute imports of non lib-based assets.
       if (from == null) return null;
 
       if (assetId.package != from.package) return null;
       return new Uri(
           path: path.relative(assetId.path, from: path.dirname(from.path)));
     }
 
     return Uri.parse('package:${assetId.package}/${assetId.path.substring(4)}');
   }
 }
 
 /// Implementation of Analyzer's UriResolver for Barback based assets.
 class _AssetUriResolver implements UriResolver {
   final ResolverImpl _resolver;
   _AssetUriResolver(this._resolver);
 
-  Source resolveAbsolute(ContentCache contentCache, Uri uri) {
+  Source resolveAbsolute(Uri uri) {
     var assetId = _resolve(null, uri.toString(), logger, null);
     var source = _resolver.sources[assetId];
     /// All resolved assets should be available by this point.
     if (source == null) {
       logger.error('Unable to find asset for "$uri"');
     }
     return source;
   }
 
-  Source fromEncoding(ContentCache contentCache, UriKind kind, Uri uri) =>
+  Source fromEncoding(UriKind kind, Uri uri) =>
       throw new UnsupportedError('fromEncoding is not supported');
 
   Uri restoreAbsolute(Source source) =>
       throw new UnsupportedError('restoreAbsolute is not supported');
 
   TransformLogger get logger => _resolver._currentTransform.logger;
 }
 
 
 /// Dart SDK which wraps all Dart sources to ensure they are tracked with Uris.
 ///
 /// Just a simple wrapper to make it easy to make sure that all sources we
 /// encounter are either _AssetBasedSource or _DartSourceProxy.
 class _DirectoryBasedDartSdkProxy extends DirectoryBasedDartSdk {
   _DirectoryBasedDartSdkProxy(JavaFile sdkDirectory) : super(sdkDirectory);
 
   Source mapDartUri(String dartUri) =>
       _DartSourceProxy.wrap(super.mapDartUri(dartUri), Uri.parse(dartUri));
 }
 
 
 /// Dart SDK resolver which wraps all Dart sources to ensure they are tracked
 /// with URIs.
 class DartUriResolverProxy implements DartUriResolver {
   final DartUriResolver _proxy;
   DartUriResolverProxy(DirectoryBasedDartSdk sdk) :
       _proxy = new DartUriResolver(sdk);
 
-  Source resolveAbsolute(ContentCache contentCache, Uri uri) =>
-    _DartSourceProxy.wrap(_proxy.resolveAbsolute(contentCache, uri), uri);
+  Source resolveAbsolute(Uri uri) =>
+    _DartSourceProxy.wrap(_proxy.resolveAbsolute(uri), uri);
 
   DartSdk get dartSdk => _proxy.dartSdk;
 
-  Source fromEncoding(ContentCache contentCache, UriKind kind, Uri uri) =>
+  Source fromEncoding(UriKind kind, Uri uri) =>
       throw new UnsupportedError('fromEncoding is not supported');
 
   Uri restoreAbsolute(Source source) =>
       throw new UnsupportedError('restoreAbsolute is not supported');
 }
 
 /// Source file for dart: sources which track the sources with dart: URIs.
 ///
 /// This is primarily to support [Resolver.getImportUri] for Dart SDK (dart:)
 /// based libraries.
@@ skipping 19 matching lines @@
     return wrap(_proxy.resolveRelative(relativeUri), uri);
   }
 
   bool exists() => _proxy.exists();
 
   bool operator ==(Object other) =>
     (other is _DartSourceProxy && _proxy == other._proxy);
 
   int get hashCode => _proxy.hashCode;
 
-  void getContents(Source_ContentReceiver receiver) {
-    _proxy.getContents(receiver);
+  void getContentsToReceiver(Source_ContentReceiver receiver) {
+    _proxy.getContentsToReceiver(receiver);
   }
 
+  TimestampedData<String> get contents => _proxy.contents;
+
   String get encoding => _proxy.encoding;
 
   String get fullName => _proxy.fullName;
 
   int get modificationStamp => _proxy.modificationStamp;
 
   String get shortName => _proxy.shortName;
 
   UriKind get uriKind => _proxy.uriKind;
 
@@ skipping 80 matching lines @@
 
   /**
    * A Future that complets with a List of the values from all the added
    * tasks, when they have all completed.
    *
    * If any task fails, this Future will receive the error. Only the first
    * error will be sent to the Future.
    */
   Future<List<E>> get future => _completer.future;
 }