Update charted to 0.4.8 and roll

packages/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 parseDirectives;
-import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
+import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/src/generated/constant.dart'
     show ConstantEvaluator, EvaluationResult;
-import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/assets.dart';
 import 'package:path/path.dart' as native_path;
 import 'package:source_maps/refactor.dart';
 import 'package:source_span/source_span.dart';
 
 import 'resolver.dart';
 import 'dart_sdk.dart' show UriAnnotatedSource;
 
 // We should always be using url paths here since it's always Dart/pub code.
 final path = native_path.url;
 
 /// Resolves and updates an AST based on Barback-based assets.
 ///
 /// This also provides a handful of useful APIs for traversing and working
 /// with the resolved AST.
 class ResolverImpl implements Resolver {
   /// Cache of all asset sources currently referenced.
-  final Map<AssetId, _AssetBasedSource> sources =
-      <AssetId, _AssetBasedSource>{};
+  final Map<AssetId, AssetBasedSource> sources = {};
 
   final InternalAnalysisContext _context =
       AnalysisEngine.instance.createAnalysisContext();
 
   /// Transform for which this is currently updating, or null when not updating.
   Transform _currentTransform;
 
   /// The currently resolved entry libraries, or null if nothing is resolved.
   List<LibraryElement> _entryLibraries;
   Set<LibraryElement> _libraries;
 
   /// Future indicating when this resolver is done in the current phase.
   Future _lastPhaseComplete = new Future.value();
 
   /// Completer for wrapping up the current phase.
   Completer _currentPhaseComplete;
 
   /// Creates a resolver with a given [sdk] implementation for resolving
   /// `dart:*` imports.
   ResolverImpl(DartSdk sdk, DartUriResolver dartUriResolver,
       {AnalysisOptions options}) {
     if (options == null) {
       options = new AnalysisOptionsImpl()
-        ..cacheSize = 256 // # of sources to cache ASTs for.
         ..preserveComments = false
         ..analyzeFunctionBodies = true;
     }
     _context.analysisOptions = options;
-    sdk.context.analysisOptions = options;
     _context.sourceFactory =
         new SourceFactory([dartUriResolver, new _AssetUriResolver(this)]);
   }
 
+  @override
+  bool isLibrary(AssetId assetId) {
+    var source = sources[assetId];
+    return source != null && _isLibrary(source);
+  }
+
+  bool _isLibrary(Source source) =>
+      _context.computeKindOf(source) == SourceKind.LIBRARY;
+
+  @override
   LibraryElement getLibrary(AssetId assetId) {
     var source = sources[assetId];
-    return source == null ? null : _context.computeLibraryElement(source);
+    if (source == null) return null;
+    if (!_isLibrary(source)) return null;
+    return _context.computeLibraryElement(source);
   }
 
-  Future<Resolver> resolve(Transform transform, [List<AssetId> entryPoints]) {
+  Future<Resolver> resolve(Transform transform,
+      [List<AssetId> entryPoints, bool resolveAllLibraries]) {
     // 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.whenComplete(() {
       _currentPhaseComplete = phaseComplete;
-      return _performResolve(transform,
-          entryPoints == null ? [transform.primaryInput.id] : entryPoints);
+      return _performResolve(
+          transform,
+          entryPoints == null ? [transform.primaryInput.id] : entryPoints,
+          resolveAllLibraries);
     }).then((_) => this);
     // Advance the lastPhaseComplete to be done when this phase is all done.
     _lastPhaseComplete = phaseComplete.future;
     return future;
   }
 
   void release() {
     if (_currentPhaseComplete == null) {
       throw new StateError('Releasing without current lock.');
     }
     _currentPhaseComplete.complete(null);
     _currentPhaseComplete = null;
 
     // Clear out libraries since they should not be referenced after release.
     _entryLibraries = null;
     _libraries = null;
     _currentTransform = null;
   }
 
-  Future _performResolve(Transform transform, List<AssetId> entryPoints) {
+  Future _performResolve(Transform transform, List<AssetId> entryPoints,
+      bool resolveAllLibraries) {
+    resolveAllLibraries ??= true;
     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);
+          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) {
         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 =
-          sources.keys.toSet().difference(visited).map((id) => sources[id]);
-      for (var unreachable in unreachableAssets) {
-        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) {
         var source = sources[id];
         if (source == null) return null;
+        var kind = _context.computeKindOf(source);
+        if (kind != SourceKind.LIBRARY) return null;
         return _context.computeLibraryElement(source);
       }).toList();
+
+      if (resolveAllLibraries) {
+        // Force resolve all other available libraries. As of analyzer > 0.27.1
+        // this is necessary to get resolved constants.
+        var newLibraries = new Set<LibraryElement>();
+        for (var library in libraries) {
+          if (library.source.uri.scheme == 'dart' ||
+              _entryLibraries.contains(library)) {
+            newLibraries.add(library);
+          } else {
+            newLibraries.add(_context
+                .computeLibraryElement(library.definingCompilationUnit.source));
+          }
+        }
+        _libraries = newLibraries;
+      }
     });
   }
 
   Iterable<LibraryElement> get libraries {
     if (_libraries == null) {
       // Note: we don't use `lib.visibleLibraries` because that excludes the
       // exports seen in the entry libraries.
       _libraries = new Set<LibraryElement>();
       _entryLibraries.forEach(_collectLibraries);
     }
@@ skipping 60 matching lines @@
         .evaluate(expression);
   }
 
   Uri getImportUri(LibraryElement lib, {AssetId from}) =>
       _getSourceUri(lib, from: from);
 
   /// Similar to getImportUri but will get the part URI for parts rather than
   /// the library URI.
   Uri _getSourceUri(Element element, {AssetId from}) {
     var source = element.source;
-    if (source is _AssetBasedSource) {
+    if (source is AssetBasedSource) {
       var uriString = assetIdToUri(source.assetId, from: from);
       return uriString != null ? Uri.parse(uriString) : null;
     } else if (source is UriAnnotatedSource) {
       return source.uri;
     }
     // Should not be able to encounter any other source types.
     throw new StateError('Unable to resolve URI for ${source.runtimeType}');
   }
 
   AssetId getSourceAssetId(Element element) {
     var source = element.source;
-    if (source is _AssetBasedSource) return source.assetId;
+    if (source is AssetBasedSource) return source.assetId;
     return null;
   }
 
   SourceSpan getSourceSpan(Element element) {
     var sourceFile = getSourceFile(element);
     if (sourceFile == null) return null;
-    return sourceFile.span(element.node.offset, element.node.end);
+    return sourceFile.span(
+        element.computeNode().offset, element.computeNode().end);
   }
 
   TextEditTransaction createTextEditTransaction(Element element) {
-    if (element.source is! _AssetBasedSource) return null;
+    if (element.source is! AssetBasedSource) return null;
 
     // Cannot edit unless there is an active transformer.
     if (_currentTransform == null) return null;
 
-    _AssetBasedSource source = element.source;
+    AssetBasedSource source = element.source;
     // Cannot modify assets in other packages.
     if (source.assetId.package != _currentTransform.primaryInput.id.package) {
       return null;
     }
 
     var sourceFile = getSourceFile(element);
     if (sourceFile == null) return null;
 
     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);
     var spanPath = importUri != null ? importUri.toString() : assetId.path;
     return new SourceFile(sources[assetId].rawContents, url: spanPath);
   }
 }
 
 /// Implementation of Analyzer's Source for Barback based assets.
-class _AssetBasedSource extends Source {
-
+class AssetBasedSource extends Source {
   /// Asset ID where this source can be found.
   final AssetId assetId;
 
   /// The resolver this is being used in.
   final ResolverImpl _resolver;
 
   /// Cache of dependent asset IDs, to avoid re-parsing the AST.
   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);
+  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 = parseDirectives(contents, suppressErrors: true);
     _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((d) => d is UriBasedDirective)
+        .map((d) => _resolve(assetId, (d as UriBasedDirective).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;
     _contents = contents;
@@ skipping 17 matching lines @@
   ///
   /// 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() => _contents != null;
 
   bool operator ==(Object other) =>
-      other is _AssetBasedSource && assetId == other.assetId;
+      other is AssetBasedSource && assetId == other.assetId;
 
   int get hashCode => assetId.hashCode;
 
   void getContentsToReceiver(Source_ContentReceiver receiver) {
     receiver.accept(rawContents, modificationStamp);
   }
 
   String get encoding =>
       "${uriKind.encoding}${assetId.package}/${assetId.path}";
 
@@ skipping 61 matching lines @@
       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];
     // Analyzer expects that sources which are referenced but do not exist yet
     // still exist, so just make an empty source.
     if (source == null) {
-      source = new _AssetBasedSource(assetId, _resolver);
+      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 80 matching lines @@
    * 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;
+  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);
     }
   }
 }