Cache snapshots of (mostly) immutable transformer phases.

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

 library pub.dart;
 import 'dart:async';
+import 'dart:io';
 import 'dart:isolate';
 import 'package:analyzer/analyzer.dart';
 import 'package:path/path.dart' as path;
 import 'package:stack_trace/stack_trace.dart';
 import '../../../compiler/compiler.dart' as compiler;
 import '../../../compiler/implementation/filenames.dart' show appendSlash;
 import '../../asset/dart/serialize.dart';
 import 'io.dart';
+import 'log.dart' as log;
 import 'utils.dart';
 abstract class CompilerProvider {
   Uri get libraryRoot;
   Future provideInput(Uri uri);
   void handleDiagnostic(Uri uri, int begin, int end, String message,
       compiler.Diagnostic kind);
   EventSink<String> provideOutput(String name, String extension);
 }
 Future compile(String entrypoint, CompilerProvider provider,
     {Iterable<String> commandLineOptions, bool checked: false, bool csp: false,
@@ skipping 44 matching lines @@
 }
 List<UriBasedDirective> parseImportsAndExports(String contents, {String name}) {
   var collector = new _DirectiveCollector();
   parseDirectives(contents, name: name).accept(collector);
   return collector.directives;
 }
 class _DirectiveCollector extends GeneralizingAstVisitor {
   final directives = <UriBasedDirective>[];
   visitUriBasedDirective(UriBasedDirective node) => directives.add(node);
 }
-Future runInIsolate(String code, message) {
+Future runInIsolate(String code, message, {String snapshot}) {
+  if (snapshot != null && fileExists(snapshot)) {
+    log.fine("Spawning isolate from $snapshot.");
+    return Chain.track(Isolate.spawnUri(path.toUri(snapshot), [], message));
+  }
   return withTempDir((dir) {
     var dartPath = path.join(dir, 'runInIsolate.dart');
     writeTextFile(dartPath, code, dontLogContents: true);
     var port = new ReceivePort();
     return Chain.track(Isolate.spawn(_isolateBuffer, {
       'replyTo': port.sendPort,
       'uri': path.toUri(dartPath).toString(),
       'message': message
     })).then((_) => port.first).then((response) {
       if (response['type'] == 'success') return null;
       assert(response['type'] == 'error');
       return new Future.error(
           new CrossIsolateException.deserialize(response['error']),
           new Chain.current());
+    }).then((_) {
+      if (snapshot == null) return null;
+      ensureDir(path.dirname(snapshot));
+      return runProcess(
+          Platform.executable,
+          ['--snapshot=$snapshot', dartPath]).then((result) {
+        if (result.success) return;
+        log.warning(
+            "Failed to compile a snapshot to " "${path.relative(snapshot)}:\n" +
+                result.stderr.join("\n"));
+      });
     });
   });
 }
 void _isolateBuffer(message) {
   var replyTo = message['replyTo'];
   Chain.track(
       Isolate.spawnUri(
           Uri.parse(message['uri']),
           [],
           message['message'])).then((_) => replyTo.send({
     'type': 'success'
   })).catchError((e, stack) {
     replyTo.send({
       'type': 'error',
       'error': CrossIsolateException.serialize(e, stack)
     });
   });
 }