Code transformers fixes for latest analyzer update

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/analyzer.dart' show parseCompilationUnit;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 62 matching lines @@
 
   LibraryElement getLibrary(AssetId assetId) {
     var source = sources[assetId];
     return source == null ? null : _context.computeLibraryElement(source);
   }
 
   Future<Resolver> resolve(Transform transform, [List<AssetId> entryPoints]) {
     // 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();
-    var future = _lastPhaseComplete.then((_) {
+    var future = _lastPhaseComplete.whenComplete(() {
       _currentPhaseComplete = phaseComplete;
       return _performResolve(transform,
         entryPoints == null ? [transform.primaryInput.id] : entryPoints);
     }).then((_) => this);
     // Advance the lastPhaseComplete to be done when this phase is all done.
     _lastPhaseComplete = phaseComplete.future;
     return future;
   }
 
   void release() {
@@ skipping 28 matching lines @@
         var source = sources[assetId];
         if (source == null) {
           source = new _AssetBasedSource(assetId, this);
           sources[assetId] = source;
         }
         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);
+        var source = sources[assetId];
+        if (source != null && source.exists()) {
+          _context.applyChanges(
+              new ChangeSet()..removedSource(source));
+          sources[assetId].updateContents(null);
+        }
       }));
     }
     entryPoints.forEach(processAsset);
 
     // 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);
+      var unreachableAssets = sources.keys.toSet()
+          .difference(visited)
+          .map((id) => sources[id]);
       for (var unreachable in unreachableAssets) {
-        changeSet.removedSource(sources[unreachable]);
-        sources.remove(unreachable);
+        changeSet.removedSource(unreachable);
+        unreachable.updateContents(null);
+        sources.remove(unreachable.assetId);
       }
 
       // Update the analyzer context with the latest sources
       _context.applyChanges(changeSet);
       // Force resolve each entry point (the getter will ensure the library is
       // computed first).
       _entryLibraries = entryPoints
           .map((id) => _context.computeLibraryElement(sources[id])).toList();
     });
   }
@@ skipping 158 matching lines @@
   ///
   /// Returns true if the contents of this asset have changed.
   bool updateContents(String contents) {
     if (contents == _contents) return false;
     _contents = contents;
     ++_revision;
     return true;
   }
 
   /// Contents of the file.
-  TimestampedData<String> get contents =>
-      new TimestampedData<String>(modificationStamp, _contents);
+  TimestampedData<String> get contents {
+    if (!exists()) throw new StateError('$assetId does not exist');
+
+    return 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 exists() => _contents != null;
 
   bool operator ==(Object other) =>
       other is _AssetBasedSource && assetId == other.assetId;
 
   int get hashCode => assetId.hashCode;
 
   void getContentsToReceiver(Source_ContentReceiver receiver) {
     receiver.accept(rawContents, modificationStamp);
   }
 
@@ skipping 52 matching lines @@
   }
 }
 
 /// Implementation of Analyzer's UriResolver for Barback based assets.
 class _AssetUriResolver implements UriResolver {
   final ResolverImpl _resolver;
   _AssetUriResolver(this._resolver);
 
   Source resolveAbsolute(Uri uri) {
     var assetId = _resolve(null, uri.toString(), logger, null);
+    if (assetId == null) {
+      logger.error('Unable to resolve asset ID for "$uri"');
+      return null;
+    }
     var source = _resolver.sources[assetId];
-    /// All resolved assets should be available by this point.
+    // Analyzer expects that sources which are referenced but do not exist yet
+    // still exist, so just make an empty source.
     if (source == null) {
-      logger.error('Unable to find asset for "$uri"');
+      source = new _AssetBasedSource(assetId, _resolver);
+      _resolver.sources[assetId] = source;
     }
     return source;
   }
 
   Source fromEncoding(UriKind kind, Uri uri) =>
       throw new UnsupportedError('fromEncoding is not supported');
 
   Uri restoreAbsolute(Source source) =>
       throw new UnsupportedError('restoreAbsolute is not supported');
 
@@ skipping 145 matching lines @@
         _completer.complete(results);
       }
     }, onError: (e, s) {
       if (_failedTask != null) return;
       _failedTask = task;
       _completer.completeError(e, s);
     });
   }
 
   /**
-   * A Future that complets with a List of the values from all the added
+   * A Future that completes 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;
 }
 
 /// 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);
     }
   }
 }