Cache snapshots of (mostly) immutable transformer phases.

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

Index: sdk/lib/_internal/pub_generated/lib/src/barback/load_all_transformers.dart
diff --git a/sdk/lib/_internal/pub_generated/lib/src/barback/load_all_transformers.dart b/sdk/lib/_internal/pub_generated/lib/src/barback/load_all_transformers.dart
index 94127b0d90324632258a29c8d1fe1884e825d5bb..3bfb0c88379c36b31d8a2b5b2032a90147fad5ca 100644
--- a/sdk/lib/_internal/pub_generated/lib/src/barback/load_all_transformers.dart
+++ b/sdk/lib/_internal/pub_generated/lib/src/barback/load_all_transformers.dart
@@ -1,84 +1,199 @@
 library pub.load_all_transformers;
 import 'dart:async';
-import 'package:barback/barback.dart';
 import '../log.dart' as log;
 import '../package_graph.dart';
 import '../utils.dart';
 import 'asset_environment.dart';
 import 'barback_server.dart';
-import 'dart2js_transformer.dart';
-import 'excluding_transformer.dart';
 import 'rewrite_import_transformer.dart';
-import 'transformer_config.dart';
+import 'transformer_cache.dart';
 import 'transformer_id.dart';
-import 'transformer_isolate.dart';
+import 'transformer_loader.dart';
 import 'transformers_needed_by_transformers.dart';
 Future loadAllTransformers(AssetEnvironment environment,
     BarbackServer transformerServer) {
-  var transformersNeededByTransformers =
-      computeTransformersNeededByTransformers(environment.graph);
-  var buffer = new StringBuffer();
-  buffer.writeln("Transformer dependencies:");
-  transformersNeededByTransformers.forEach((id, dependencies) {
-    if (dependencies.isEmpty) {
-      buffer.writeln("$id: -");
-    } else {
-      buffer.writeln("$id: ${toSentence(dependencies)}");
-    }
-  });
-  log.fine(buffer);
-  var phasedTransformers = _phaseTransformers(transformersNeededByTransformers);
-  var packagesThatUseTransformers =
-      _packagesThatUseTransformers(environment.graph);
-  var loader = new _TransformerLoader(environment, transformerServer);
-  var rewrite = new RewriteImportTransformer();
-  for (var package in environment.packages) {
-    environment.barback.updateTransformers(package, [[rewrite]]);
-  }
-  environment.barback.updateTransformers(r'$pub', [[rewrite]]);
-  return Future.forEach(phasedTransformers, (phase) {
-    return loader.load(phase).then((_) {
-      var packagesToUpdate =
-          unionAll(phase.map((id) => packagesThatUseTransformers[id]));
-      return Future.wait(packagesToUpdate.map((packageName) {
-        var package = environment.graph.packages[packageName];
-        return loader.transformersForPhases(
-            package.pubspec.transformers).then((phases) {
-          phases.insert(0, new Set.from([rewrite]));
-          environment.barback.updateTransformers(packageName, phases);
-        });
+  final completer0 = new Completer();
+  scheduleMicrotask(() {
+    try {
+      var transformersNeededByTransformers =
+          computeTransformersNeededByTransformers(environment.graph);
+      var buffer = new StringBuffer();
+      buffer.writeln("Transformer dependencies:");
+      transformersNeededByTransformers.forEach(((id, dependencies) {
+        if (dependencies.isEmpty) {
+          buffer.writeln("$id: -");
+        } else {
+          buffer.writeln("$id: ${toSentence(dependencies)}");
+        }
       }));
-    });
-  }).then((_) {
-    return Future.wait(environment.graph.packages.values.map((package) {
-      return loader.transformersForPhases(
-          package.pubspec.transformers).then((phases) {
-        var transformers = environment.getBuiltInTransformers(package);
-        if (transformers != null) phases.add(transformers);
-        newFuture(
-            () => environment.barback.updateTransformers(package.name, phases));
-      });
-    }));
+      log.fine(buffer);
+      var stagedTransformers =
+          _stageTransformers(transformersNeededByTransformers);
+      var packagesThatUseTransformers =
+          _packagesThatUseTransformers(environment.graph);
+      var loader = new TransformerLoader(environment, transformerServer);
+      var rewrite = new RewriteImportTransformer();
+      var it0 = environment.packages.iterator;
+      break0(x9) {
+        environment.barback.updateTransformers(r'$pub', [[rewrite]]);
+        join0(x0) {
+          var cache = x0;
+          var first = true;
+          var it1 = stagedTransformers.iterator;
+          break1(x6) {
+            cache.save();
+            Future.wait(environment.graph.packages.values.map(((package) {
+              final completer0 = new Completer();
+              scheduleMicrotask(() {
+                try {
+                  loader.transformersForPhases(
+                      package.pubspec.transformers).then((x0) {
+                    try {
+                      var phases = x0;
+                      var transformers =
+                          environment.getBuiltInTransformers(package);
+                      join0() {
+                        newFuture(
+                            (() => environment.barback.updateTransformers(package.name, phases)));
+                        completer0.complete(null);
+                      }
+                      if (transformers != null) {
+                        phases.add(transformers);
+                        join0();
+                      } else {
+                        join0();
+                      }
+                    } catch (e0) {
+                      completer0.completeError(e0);
+                    }
+                  }, onError: (e1) {
+                    completer0.completeError(e1);
+                  });
+                } catch (e2) {
+                  completer0.completeError(e2);
+                }
+              });
+              return completer0.future;
+            }))).then((x1) {
+              try {
+                x1;
+                completer0.complete(null);
+              } catch (e0) {
+                completer0.completeError(e0);
+              }
+            }, onError: (e1) {
+              completer0.completeError(e1);
+            });
+          }
+          continue1(x7) {
+            if (it1.moveNext()) {
+              Future.wait([]).then((x5) {
+                var stage = it1.current;
+                join1(x2) {
+                  var snapshotPath = x2;
+                  first = false;
+                  loader.load(stage, snapshot: snapshotPath).then((x3) {
+                    try {
+                      x3;
+                      var packagesToUpdate =
+                          unionAll(stage.map(((id) => packagesThatUseTransformers[id])));
+                      Future.wait(packagesToUpdate.map(((packageName) {
+                        final completer0 = new Completer();
+                        scheduleMicrotask(() {
+                          try {
+                            var package =
+                                environment.graph.packages[packageName];
+                            loader.transformersForPhases(
+                                package.pubspec.transformers).then((x0) {
+                              try {
+                                var phases = x0;
+                                phases.insert(0, new Set.from([rewrite]));
+                                environment.barback.updateTransformers(
+                                    packageName,
+                                    phases);
+                                completer0.complete(null);
+                              } catch (e0) {
+                                completer0.completeError(e0);
+                              }
+                            }, onError: (e1) {
+                              completer0.completeError(e1);
+                            });
+                          } catch (e2) {
+                            completer0.completeError(e2);
+                          }
+                        });
+                        return completer0.future;
+                      }))).then((x4) {
+                        try {
+                          x4;
+                          continue1(null);
+                        } catch (e3) {
+                          completer0.completeError(e3);
+                        }
+                      }, onError: (e4) {
+                        completer0.completeError(e4);
+                      });
+                    } catch (e2) {
+                      completer0.completeError(e2);
+                    }
+                  }, onError: (e5) {
+                    completer0.completeError(e5);
+                  });
+                }
+                if (cache == null || !first) {
+                  join1(null);
+                } else {
+                  join1(cache.snapshotPath(stage));
+                }
+              });
+            } else {
+              break1(null);
+            }
+          }
+          continue1(null);
+        }
+        if (environment.rootPackage.dir == null) {
+          join0(null);
+        } else {
+          join0(environment.graph.loadTransformerCache());
+        }
+      }
+      continue0(x10) {
+        if (it0.moveNext()) {
+          Future.wait([]).then((x8) {
+            var package = it0.current;
+            environment.barback.updateTransformers(package, [[rewrite]]);
+            continue0(null);
+          });
+        } else {
+          break0(null);
+        }
+      }
+      continue0(null);
+    } catch (e6) {
+      completer0.completeError(e6);
+    }
   });
+  return completer0.future;
 }
-List<Set<TransformerId>> _phaseTransformers(Map<TransformerId,
+List<Set<TransformerId>> _stageTransformers(Map<TransformerId,
     Set<TransformerId>> transformerDependencies) {
-  var phaseNumbers = {};
-  var phases = [];
-  phaseNumberFor(id) {
-    if (phaseNumbers.containsKey(id)) return phaseNumbers[id];
+  var stageNumbers = {};
+  var stages = [];
+  stageNumberFor(id) {
+    if (stageNumbers.containsKey(id)) return stageNumbers[id];
     var dependencies = transformerDependencies[id];
-    phaseNumbers[id] =
-        dependencies.isEmpty ? 0 : maxAll(dependencies.map(phaseNumberFor)) + 1;
-    return phaseNumbers[id];
+    stageNumbers[id] =
+        dependencies.isEmpty ? 0 : maxAll(dependencies.map(stageNumberFor)) + 1;
+    return stageNumbers[id];
   }
   for (var id in transformerDependencies.keys) {
-    var phaseNumber = phaseNumberFor(id);
-    if (phases.length <= phaseNumber) phases.length = phaseNumber + 1;
-    if (phases[phaseNumber] == null) phases[phaseNumber] = new Set();
-    phases[phaseNumber].add(id);
+    var stageNumber = stageNumberFor(id);
+    if (stages.length <= stageNumber) stages.length = stageNumber + 1;
+    if (stages[stageNumber] == null) stages[stageNumber] = new Set();
+    stages[stageNumber].add(id);
   }
-  return phases;
+  return stages;
 }
 Map<TransformerId, Set<String>> _packagesThatUseTransformers(PackageGraph graph)
     {
@@ -92,77 +207,3 @@ Map<TransformerId, Set<String>> _packagesThatUseTransformers(PackageGraph graph)
   }
   return results;
 }
-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) {
-    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);
-    }).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();
-    });
-  }
-}