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((_) {
+      return this;
+    });

[Siggi Cherem (dart-lang), 2014/02/27 18:20:41]

style nit: use (_) => this, maybe fold into the previous then block?

For example:

var future = _lastPhaseComplete.then((_) {
   _currentPhaseComplete = phaseComplete;
   return _performResolve(transform).then((_) => this);
}


Alternatively, you could do:

var future = _lastPhaseComplete
   .then((_) { _currentPhaseComplete = phaseComplete; })
   .then((_) => _performResolve(transform))
   .then((_) => this);

[blois, 2014/02/27 23:47:17]

Done.

+    // 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 439 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;
 }