Fixes code_transformers after the latest analyzer changes

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';
+import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_io.dart';
+import 'package:analyzer/src/generated/parser.dart';
+import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as native_path;
 import 'package:source_maps/refactor.dart';
 import 'package:source_maps/span.dart' show SourceFile, Span;
 
 import 'resolver.dart';
 
@@ skipping 82 matching lines @@
   Future _performResolve(Transform transform) {
     if (_currentTransform != null) {
       throw new StateError('Cannot be accessed by concurrent transforms');
     }
     _currentTransform = transform;
 
     // Basic approach is to start at the first file, update it's contents
     // and see if it changed, then walk all files accessed by it.
     var visited = new Set<AssetId>();
     var visiting = new FutureGroup();
+    var toUpdate = [];
 
     void processAsset(AssetId assetId) {
       visited.add(assetId);
 
       visiting.add(transform.readInputAsString(assetId).then((contents) {
         var source = sources[assetId];
         if (source == null) {
           source = new _AssetBasedSource(assetId, this);
           sources[assetId] = source;
         }
-        source.updateContents(contents);
-
-        source.dependentAssets
-            .where((id) => !visited.contains(id))
+        source.updateDependencies(contents);
+        toUpdate.add(new _PendingUpdate(source, contents));
+        source.dependentAssets.where((id) => !visited.contains(id))
             .forEach(processAsset);
-
       }, onError: (e) {
         _context.applyChanges(new ChangeSet()..removedSource(sources[assetId]));
         sources.remove(assetId);
       }));
     }
     processAsset(entryPoint);
 
     // Once we have all asset sources updated with the new contents then
     // resolve everything.
     return visiting.future.then((_) {
       var changeSet = new ChangeSet();
+      toUpdate.forEach((pending) => pending.apply(changeSet));
       var unreachableAssets = new Set.from(sources.keys).difference(visited);
       for (var unreachable in unreachableAssets) {
         changeSet.removedSource(sources[unreachable]);
         sources.remove(unreachable);
       }
 
       // Update the analyzer context with the latest sources
       _context.applyChanges(changeSet);
       // Resolve the AST
       _entryLibrary = _context.computeLibraryElement(sources[entryPoint]);
@@ skipping 117 matching lines @@
   Iterable<AssetId> _dependentAssets;
 
   /// The current revision of the file, incremented only when file changes.
   int _revision = 0;
 
   /// The file contents.
   String _contents;
 
   _AssetBasedSource(this.assetId, this._resolver);
 
+  /// Update the dependencies of this source. This parses [contents] but avoids
+  /// any analyzer resolution.
+  void updateDependencies(String contents) {
+    if (contents == _contents) return;
+    var unit = _parseCompilationUnit(contents);
+    _dependentAssets = unit.directives
+        .where((d) => (d is ImportDirective || d is PartDirective ||
+            d is ExportDirective))
+        .map((d) => _resolve(assetId, d.uri.stringValue, _logger,
+              _getSpan(d, contents)))
+        .where((id) => id != null).toSet();
+  }
+
   /// Update the contents of this file with [contents].
   ///
   /// Returns true if the contents of this asset have changed.
   bool updateContents(String contents) {
     if (contents == _contents) return false;
-    var added = _contents == null;
     _contents = contents;
     ++_revision;
-    // Invalidate the imports so we only parse the AST when needed.
-    _dependentAssets = null;
-
-    if (added) {
-      _resolver._context.applyChanges(new ChangeSet()..addedSource(this));
-    } else {
-      _resolver._context.applyChanges(new ChangeSet()..changedSource(this));
-    }
-
-    var compilationUnit = _resolver._context.parseCompilationUnit(this);
-    _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.
   TimestampedData<String> get contents =>
       new TimestampedData<String>(modificationStamp, _contents);
 
   /// Contents of the file.
   String get rawContents => _contents;
 
@@ skipping 38 matching lines @@
 
     // The entire AST should have been parsed and loaded at this point.
     var source = _resolver.sources[id];
     if (source == null) {
       _logger.error('Could not load asset $id');
     }
     return source;
   }
 
   /// For logging errors.
-  Span _getSpan(AstNode node) => _sourceFile.span(node.offset, node.end);
+  Span _getSpan(AstNode node, [String contents]) =>
+      _getSourceFile(contents).span(node.offset, node.end);
   /// For logging errors.
-  SourceFile get _sourceFile {
+  SourceFile _getSourceFile([String contents]) {
     var uri = getSourceUri(_resolver.entryPoint);
     var path = uri != null ? uri.toString() : assetId.path;
-
-    return new SourceFile.text(path, rawContents);
+    return new SourceFile.text(path, contents != null ? contents : 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;
 
@@ skipping 190 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;
 }
+
+/// Parse [code] using just the analyzer's parser, without actually getting the
+/// resolver to run.
+CompilationUnit _parseCompilationUnit(String code) {

[blois, 2014/03/17 16:29:46]

Should be able to use package:analyzer/analyzer.dart's parseCompilationUnit.

[Siggi Cherem (dart-lang), 2014/03/17 17:58:09]

Done.

+  var errorListener = new _ErrorCollector();
+  var reader = new CharSequenceReader(code);
+  var scanner = new Scanner(null, reader, errorListener);
+  var token = scanner.tokenize();
+  var parser = new Parser(null, errorListener);
+  return parser.parseCompilationUnit(token);
+}
+
+class _ErrorCollector extends AnalysisErrorListener {
+  final errors = <AnalysisError>[];
+  onError(error) => errors.add(error);
+}
+
+/// A pending update to notify the resolver that a [Source] has been added or
+/// changed. This is used by the `_performResolve` algorithm above to apply all
+/// changes after it first discovers the transitive closure of files that are
+/// reachable from the sources.
+class _PendingUpdate {
+  _AssetBasedSource source;
+  String content;
+
+  _PendingUpdate(this.source, this.content);
+
+  void apply(ChangeSet changeSet) {
+    if (!source.updateContents(content)) return;
+    if (source._revision == 1 && source._contents != null) {
+      changeSet.addedSource(source);
+    } else {
+      changeSet.changedSource(source);
+    }
+  }
+}