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/analyzer.dart' show parseCompilationUnit;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 17 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;
+  /// The currently resolved entry libraries, or null if nothing is resolved.
+  List<LibraryElement> _entryLibraries;
 
   /// 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}) {
+  /// 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) {
+    var source = sources[assetId];
+    return source == null ? null : _context.computeLibraryElement(source);
+  }
 
-  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.
+    _entryLibraries = null;
+    _currentTransform = 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();
     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.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);
+    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);
       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]);
-      _currentTransform = null;
+      // Force resolve each entry point (the getter will ensure the library is
+      // computed first).
+      _entryLibraries = entryPoints
+          .map((id) => _context.computeLibraryElement(sources[id])).toList();
     });
   }
 
-  Iterable<LibraryElement> get libraries => entryLibrary.visibleLibraries;
+  Iterable<LibraryElement> get libraries =>
+      _entryLibraries.expand((lib) => lib.visibleLibraries).toSet();
 
   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;
@@ skipping 87 matching lines @@
       _logger.error('Could not load asset $id');
     }
     return source;
   }
 
   /// For logging errors.
   Span _getSpan(AstNode node, [String contents]) =>
       _getSourceFile(contents).span(node.offset, node.end);
   /// For logging errors.
   SourceFile _getSourceFile([String contents]) {
-    var uri = getSourceUri(_resolver.entryPoint);
+    var uri = getSourceUri();
     var path = uri != null ? uri.toString() : assetId.path;
     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.
@@ skipping 212 matching lines @@
 
   void apply(ChangeSet changeSet) {
     if (!source.updateContents(content)) return;
     if (source._revision == 1 && source._contents != null) {
       changeSet.addedSource(source);
     } else {
       changeSet.changedSource(source);
     }
   }
 }