Cache snapshots of (mostly) immutable transformer phases.

sdk/lib/_internal/pub_generated/lib/src/barback/transformer_loader.dart

Index: sdk/lib/_internal/pub_generated/lib/src/barback/transformer_loader.dart
diff --git a/sdk/lib/_internal/pub_generated/lib/src/barback/transformer_loader.dart b/sdk/lib/_internal/pub_generated/lib/src/barback/transformer_loader.dart
new file mode 100644
index 0000000000000000000000000000000000000000..b11a366624575d6426245fec25224e1b752f32d5
--- /dev/null
+++ b/sdk/lib/_internal/pub_generated/lib/src/barback/transformer_loader.dart
@@ -0,0 +1,90 @@
+library pub.barback.transformer_loader;
+import 'dart:async';
+import 'package:barback/barback.dart';
+import '../log.dart' as log;
+import '../utils.dart';
+import 'asset_environment.dart';
+import 'barback_server.dart';
+import 'dart2js_transformer.dart';
+import 'excluding_transformer.dart';
+import 'transformer_config.dart';
+import 'transformer_id.dart';
+import 'transformer_isolate.dart';
+class TransformerLoader {
+  final AssetEnvironment _environment;
+  final BarbackServer _transformerServer;
+  final _isolates = new Map<TransformerId, TransformerIsolate>();
+  final _transformers = new Map<TransformerConfig, Set<Transformer>>();
+  final _transformerUsers = new Map<TransformerId, Set<String>>();
+  TransformerLoader(this._environment, this._transformerServer) {
+    for (var package in _environment.graph.packages.values) {
+      for (var config in unionAll(package.pubspec.transformers)) {
+        _transformerUsers.putIfAbsent(
+            config.id,
+            () => new Set<String>()).add(package.name);
+      }
+    }
+  }
+  Future load(Iterable<TransformerId> ids, {String snapshot}) {
+    ids = ids.where((id) => !_isolates.containsKey(id)).toList();
+    if (ids.isEmpty) return new Future.value();
+    return log.progress("Loading ${toSentence(ids)} transformers", () {
+      return TransformerIsolate.spawn(
+          _environment,
+          _transformerServer,
+          ids,
+          snapshot: snapshot);
+    }).then((isolate) {
+      for (var id in ids) {
+        _isolates[id] = isolate;
+      }
+    });
+  }
+  Future<Set<Transformer>> transformersFor(TransformerConfig config) {
+    if (_transformers.containsKey(config)) {
+      return new Future.value(_transformers[config]);
+    } else if (_isolates.containsKey(config.id)) {
+      return _isolates[config.id].create(config).then((transformers) {
+        if (transformers.isNotEmpty) {
+          _transformers[config] = transformers;
+          return transformers;
+        }
+        var message = "No transformers";
+        if (config.configuration.isNotEmpty) {
+          message += " that accept configuration";
+        }
+        var location;
+        if (config.id.path == null) {
+          location =
+              'package:${config.id.package}/transformer.dart or '
+                  'package:${config.id.package}/${config.id.package}.dart';
+        } else {
+          location = 'package:$config.dart';
+        }
+        var users = toSentence(ordered(_transformerUsers[config.id]));
+        fail("$message were defined in $location,\n" "required by $users.");
+      });
+    } else if (config.id.package != '\$dart2js') {
+      return new Future.value(new Set());
+    }
+    var transformer;
+    try {
+      transformer = new Dart2JSTransformer.withSettings(
+          _environment,
+          new BarbackSettings(config.configuration, _environment.mode));
+    } on FormatException catch (error, stackTrace) {
+      fail(error.message, error, stackTrace);
+    }
+    _transformers[config] =
+        new Set.from([ExcludingTransformer.wrap(transformer, config)]);
+    return new Future.value(_transformers[config]);
+  }
+  Future<List<Set<Transformer>>>
+      transformersForPhases(Iterable<Set<TransformerConfig>> phases) {
+    return Future.wait(phases.map((phase) {
+      return waitAndPrintErrors(phase.map(transformersFor)).then(unionAll);
+    })).then((phases) {
+      return phases.toList();
+    });
+  }
+}