Support serialized dart:core in batch-mode

pkg/compiler/lib/src/dart2js.dart

 // Copyright (c) 2013, 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 dart2js.cmdline;
 
-import 'dart:async' show Future;
+import 'dart:async' show EventSink, Future;
 import 'dart:convert' show UTF8, LineSplitter;
 import 'dart:io' show exit, File, FileMode, Platform, stdin, stderr;
 
 import 'package:package_config/discovery.dart' show findPackages;
 
 import '../compiler_new.dart' as api;
+import 'apiimpl.dart';
+import 'common/names.dart' show Uris;
 import 'commandline_options.dart';
 import 'filenames.dart';
 import 'io/source_file.dart';
+import 'null_compiler_output.dart';
 import 'options.dart' show CompilerOptions;
 import 'source_file_provider.dart';
 import 'util/command_line.dart';
 import 'util/uri_extras.dart';
 import 'util/util.dart' show stackTraceFilePrefix;
 
 const String LIBRARY_ROOT = '../../../../../sdk';
 const String OUTPUT_LANGUAGE_DART = 'Dart';
 
 /**
@@ skipping 752 matching lines @@
   int exitCode;
   exitFunc = (errorCode) {
     // Since we only throw another part of the compiler might intercept our
     // exception and try to exit with a different code.
     if (exitCode == 0) {
       exitCode = errorCode;
     }
     throw _EXIT_SIGNAL;
   };
 
+  if (USE_SERIALIZED_DART_CORE) {
+    CompileFunc oldCompileFunc = compileFunc;
+    String serializedData;
+    Future<api.CompilationResult> _compileFunc(CompilerOptions compilerOptions,
+        api.CompilerInput compilerInput,
+        api.CompilerDiagnostics compilerDiagnostics,
+        api.CompilerOutput compilerOutput) async {
+      if (serializedData == null) {

[Siggi Cherem (dart-lang), 2016/05/17 21:30:15]

nit: consider adding a few functions at the end of this file with the logic of
this new code. For example, I'd add:
 - a function that creates the serialized data (the body of this `if`)
 - a function that compiles given serialized data
 - a function that does the wrapping you do here.
 
So the new code here would look more like this:

if (USE_SERIALIZED_DART_CORE) {
  compileFunc = _useSerializeDataForDartCore(compileFunc);
}

_useSerializeDataForDartCore(...) {
  String serializedData;
  return (...) async {
    serializedData ??= _generateSerializedDataForDartCore(...);
    return _compilerWithSerializedData(..., serializedData);
  };
}

...

[Johnni Winther, 2016/05/18 11:00:07]

Done.

+        _CompilerOutput output = new _CompilerOutput();
+        api.CompilationResult result = await oldCompileFunc(
+            new CompilerOptions.parse(
+                entryPoint: Uris.dart_core,
+                libraryRoot: compilerOptions.libraryRoot,
+                packageRoot: compilerOptions.packageRoot,
+                packageConfig: compilerOptions.packageConfig,
+                packagesDiscoveryProvider:
+                    compilerOptions.packagesDiscoveryProvider,
+                environment:
+                    compilerOptions.environment,
+                serializationTarget: Uri.parse('file:fake.data'),
+                options: [Flags.analyzeAll]),
+            compilerInput,
+            compilerDiagnostics,
+            output);
+        serializedData = output.serializedData;
+      }
+      CompilerImpl compiler = new CompilerImpl(
+          compilerInput, compilerOutput, compilerDiagnostics, compilerOptions);
+      compiler.serialization.deserializeFromText(serializedData);
+      return compiler.run(compilerOptions.entryPoint).then((bool success) {
+        return new api.CompilationResult(compiler, isSuccess: success);
+      });
+    }
+    compileFunc = _compileFunc;
+  }
+
+
   var stream = stdin.transform(UTF8.decoder).transform(new LineSplitter());
   var subscription;
   subscription = stream.listen((line) {
     new Future.sync(() {
       subscription.pause();
       exitCode = 0;
       if (line == null) exit(0);
       List<String> args = <String>[];
       args.addAll(batchArguments);
       args.addAll(splitLine(line, windows: Platform.isWindows));
@@ skipping 10 matching lines @@
       } else if (exitCode == 253) {
         print(">>> TEST CRASH");
       } else {
         print(">>> TEST FAIL");
       }
       stderr.writeln(">>> EOF STDERR");
       subscription.resume();
     });
   });
 }
+
+final bool USE_SERIALIZED_DART_CORE =
+    Platform.environment['USE_SERIALIZED_DART_CORE'] == 'true';
+
+class _CompilerOutput extends NullCompilerOutput {
+  _BufferedEventSink sink;
+
+  @override
+  EventSink<String> createEventSink(String name, String extension) {
+    if (name == '' && extension == 'data')  {
+      return sink = new _BufferedEventSink();
+    }
+    return super.createEventSink(name, extension);
+  }
+
+  String get serializedData => sink.sb.toString();
+}
+
+class _BufferedEventSink implements EventSink<String> {
+  StringBuffer sb = new StringBuffer();
+
+  @override
+  void add(String event) {
+    sb.write(event);
+  }
+
+  @override
+  void close() {
+    // Do nothing.
+  }
+
+  @override
+  void addError(errorEvent, [StackTrace stackTrace]) {
+    // Ignore
+  }
+}