Allow multiple-entry libraries in code_transformers

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 13 matching lines @@
 
 /// 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>{};
 
-  /// The Dart entry point file where parsing begins.
-  final AssetId entryPoint;
-
   final AnalysisContext _context =
       AnalysisEngine.instance.createAnalysisContext();
 
   /// Transform for which this is currently updating, or null when not updating.
   Transform _currentTransform;
 
-  /// The currently resolved library, or null if unresolved.
-  LibraryElement _entryLibrary;
-
   /// 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;
 
   /// Handler for all Dart SDK (dart:) sources.
   DirectoryBasedDartSdk _dartSdk;
 
-  /// Creates a resolver that will resolve the Dart code starting at
-  /// [entryPoint].
-  ///
-  /// [sdkDir] is the root directory of the Dart SDK, for resolving dart:
-  /// imports.
-  ResolverImpl(this.entryPoint, String sdkDir, {AnalysisOptions options}) {
+  List<LibraryElement> _entryLibraries;
+
+  /// Creates a resolver, where [sdkDir] is the root directory of the Dart SDK,
+  /// for resolving `dart:*` imports.
+  ResolverImpl(String sdkDir, {AnalysisOptions options}) {
     if (options == null) {
       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([
         new DartUriResolverProxy(_dartSdk),
         new _AssetUriResolver(this)]);
   }
 
-  LibraryElement get entryLibrary => _entryLibrary;
+  LibraryElement getLibrary(AssetId assetId) => sources[assetId].libraryElement;
 
-  Future<Resolver> resolve(Transform transform) {
+  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((_) {
       _currentPhaseComplete = phaseComplete;
-
-      return _performResolve(transform);
+      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() {
     if (_currentPhaseComplete == null) {
       throw new StateError('Releasing without current lock.');
     }
     _currentPhaseComplete.complete(null);
     _currentPhaseComplete = null;
 
-    // Clear out the entry lib since it should not be referenced after release.
-    _entryLibrary = null;
+    // Clear out libraries since they should not be referenced after release.
+    sources.values.forEach((source) { source._libraryElement = null; });
   }
 
-  Future _performResolve(Transform transform) {
+  Future _performResolve(Transform transform, List<AssetId> entryPoints) {
     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();
 
@@ skipping 10 matching lines @@
 
         source.dependentAssets
             .where((id) => !visited.contains(id))
             .forEach(processAsset);
 
       }, onError: (e) {
         _context.applyChanges(new ChangeSet()..removedSource(sources[assetId]));
         sources.remove(assetId);
       }));
     }
-    processAsset(entryPoint);
+    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();
       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]);
+      // Force resolve each entry point (the getter will ensure the library is
+      // computed first).
+      _entryLibraries =
+          entryPoints.map((e) => sources[e].libraryElement).toList();
       _currentTransform = null;
     });
   }
 
-  Iterable<LibraryElement> get libraries => entryLibrary.visibleLibraries;
+  Iterable<LibraryElement> get libraries =>
+      _entryLibraries.expand((e) => e.visibleLibraries);
 
   LibraryElement getLibraryByName(String libraryName) =>
       libraries.firstWhere((l) => l.name == libraryName, orElse: () => null);
 
   LibraryElement getLibraryByUri(Uri uri) =>
       libraries.firstWhere((l) => getImportUri(l) == uri, orElse: () => null);
 
   ClassElement getType(String typeName) {
     var dotIndex = typeName.lastIndexOf('.');
     var libraryName = dotIndex == -1 ? '' : typeName.substring(0, dotIndex);
@@ skipping 53 matching lines @@
     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;
     return null;
   }
 
   Span getSourceSpan(Element element) {
-    var sourceFile = _getSourceFile(element);
+    var sourceFile = getSourceFile(element);
     if (sourceFile == null) return null;
     return sourceFile.span(element.node.offset, element.node.end);
   }
 
   TextEditTransaction createTextEditTransaction(Element element) {
     if (element.source is! _AssetBasedSource) return null;
 
+    // Cannot edit unless there is an active transformer.
+    if (_currentTransform == null) return null;
+
     _AssetBasedSource source = element.source;
     // Cannot modify assets in other packages.
-    if (source.assetId.package != entryPoint.package) return null;
+    if (source.assetId.package != _currentTransform.primaryInput.id.package) {
+      return null;
+    }
 
-    var sourceFile = _getSourceFile(element);
+    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) {
+  SourceFile getSourceFile(Element element) {
     var assetId = getSourceAssetId(element);
     if (assetId == null) return null;
 
-    var importUri = _getSourceUri(element, from: entryPoint);
+    var importUri = _getSourceUri(element);
     var spanPath = importUri != null ? importUri.toString() : assetId.path;
     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.
   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;
 
+  LibraryElement _libraryElement;
+
+  LibraryElement get libraryElement {
+    if (_libraryElement == null) {
+      _libraryElement = _resolver._context.computeLibraryElement(this);
+    }
+    return _libraryElement;
+  }
+
   _AssetBasedSource(this.assetId, this._resolver);
 
   /// 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;
@@ skipping 67 matching lines @@
     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);
   /// For logging errors.
   SourceFile get _sourceFile {
-    var uri = getSourceUri(_resolver.entryPoint);
+    var uri = getSourceUri();
     var path = uri != null ? uri.toString() : assetId.path;
 
     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/')) {
@@ skipping 193 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;
 }