Refactoring resolvers to make them able to be run in parallel.

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 28 matching lines @@
 
   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}) {
     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.con2([
         new DartUriResolverProxy(_dartSdk),
         new _AssetUriResolver(this)]);
   }
 
   LibraryElement get entryLibrary => _entryLibrary;
 
+  Future<Resolver> resolve(Transform transform) {
+    // 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;
 
-  /// Update the status of all the sources referenced by the entryPoint and
-  /// update the resolved library.
-  ///
-  /// This will be invoked automatically by [ResolverTransformer]. Only one
-  /// transformer may update this at a time.
-  Future updateSources(Transform transform) {
+      return _performResolve(transform);
+    }).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;
+  }
+
+  Future _performResolve(Transform transform) {
     if (_currentTransform != null) {
       throw new StateError('Cannot be accessed by concurrent transforms');
     }
     _currentTransform = transform;
-    // Clear this out and update once all asset changes have been processed.
-    _entryLibrary = null;
 
     // 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();
 
     void processAsset(AssetId assetId) {
       visited.add(assetId);
 
       visiting.add(transform.readInputAsString(assetId).then((contents) {
@@ skipping 365 matching lines @@
 
   bool get isInSystemLibrary => _proxy.isInSystemLibrary;
 }
 
 /// Get an asset ID for a URL relative to another source asset.
 AssetId _resolve(AssetId source, String url, TransformLogger logger,
     Span span) {
   if (url == null || url == '') return null;
   var uri = Uri.parse(url);
 
+  // Workaround for dartbug.com/17156- pub transforms package: imports from
+  // files of the transformers package to have absolute /packages/ URIs.
+  if (uri.scheme == '' && path.isAbsolute(url)
+      && uri.pathSegments[0] == 'packages') {
+    uri = Uri.parse('package:${uri.pathSegments.skip(1).join(path.separator)}');
+  }
+
   if (uri.scheme == 'package') {
     var segments = new List.from(uri.pathSegments);
     var package = segments[0];
     segments[0] = 'lib';
     return new AssetId(package, segments.join(path.separator));
   }
   // Dart SDK libraries do not have assets.
   if (uri.scheme == 'dart') return null;
 
   if (uri.host != '' || uri.scheme != '' || path.isAbsolute(url)) {
@@ skipping 54 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;
 }