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

pkg/code_transformers/lib/src/resolvers.dart

Index: pkg/code_transformers/lib/src/resolvers.dart
diff --git a/pkg/code_transformers/lib/src/resolvers.dart b/pkg/code_transformers/lib/src/resolvers.dart
new file mode 100644
index 0000000000000000000000000000000000000000..5539f8a85481c1cce019d5ea8c8ffa3cf3869b75
--- /dev/null
+++ b/pkg/code_transformers/lib/src/resolvers.dart
@@ -0,0 +1,58 @@
+// 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_transformers.src.resolvers;
+
+import 'dart:async';
+import 'package:barback/barback.dart' show AssetId, Transformer, Transform;
+
+import 'resolver.dart';
+import 'resolver_impl.dart';
+
+/// Barback-based code resolver which maintains up-to-date resolved ASTs for the

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

update comment?

In particular, I was a bit confused because it doesn't seems to apply to the
class below, but more as a comment for [Resolver].

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

Done.

+/// specified code entry points.
+///
+/// This can used by transformers dependent on resolved ASTs which can reference
+/// this transformer to get the resolver needed.
+///
+/// [Resolver.resolve] must be called to resolve the current AST.
+///
+/// If multiple transformers rely on a resolved AST they should (ideally) share
+/// the same Resolvers object to minimize re-parsing the AST.
+class Resolvers {
+  final Map<AssetId, ResolverImpl> _resolvers = {};
+  final String dartSdkDirectory;
+
+  Resolvers(this.dartSdkDirectory);
+
+  /// Get a resolver for the AST starting from [id].
+  Future<Resolver> get(Transform transform) {
+    var id = transform.primaryInput.id;
+    var resolver = _resolvers.putIfAbsent(id,
+        () => new ResolverImpl(id, dartSdkDirectory));
+    return resolver.resolve(transform);
+  }
+}
+
+/// Transformer mixin which automatically gets and releases resolvers.
+///
+/// To use mix this class in, set the resolvers field and override
+/// [applyResolver].
+abstract class ResolverTransformer implements Transformer {
+  /// The cache of resolvers- must be set from subclass.
+  Resolvers resolvers;
+
+  Future apply(Transform transform) {
+    return resolvers.get(transform).then((resolver) {
+      return new Future.value(applyResolver(transform, resolver)).then((_) {
+        resolver.release();
+      });
+    });
+  }
+
+  /// Invoked when the resolver is ready to be processed.
+  ///
+  /// Return a Future to indicate when apply is completed.
+  applyResolver(Transform transform, Resolver resolver);
+}