Serialize only unserialized libraries on --resolve-only

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 EventSink, Future;
 import 'dart:convert' show UTF8, LineSplitter;
 import 'dart:io' show exit, File, FileMode, Platform, stdin, stderr;
 
@@ skipping 453 matching lines @@
       diagnosticHandler.info(
           "Option '${Flags.analyzeAll}' implies '${Flags.analyzeOnly}'.",
           api.Diagnostic.INFO);
     }
     diagnosticHandler.info(
         "Options $optionsImplyOutput indicate that output is expected, "
         "but compilation is turned off by the option '${Flags.analyzeOnly}'.",
         api.Diagnostic.INFO);
   }
   if (resolveOnly) {
+    if (resolutionInputs.contains(resolutionOutput)) {
+      helpAndFail("Resolution input '${resolutionOutput}' can't be used as "
+      "resolution output. Use the '--out' option to specify another resolution "
+      "output.");
+    }
     analyzeOnly = analyzeAll = true;
   } else if (analyzeAll) {
     analyzeOnly = true;
   }
   if (!analyzeOnly) {
     if (allowNativeExtensions) {
       helpAndFail("Option '${Flags.allowNativeExtensions}' is only supported "
           "in combination with the '${Flags.analyzeOnly}' option.");
     }
   }
@@ skipping 354 matching lines @@
 // TODO(johnniwinther): Add corresponding options to the test script and change
 // these to use 'bool.fromEnvironment'.
 final bool USE_SERIALIZED_DART_CORE =
     Platform.environment['USE_SERIALIZED_DART_CORE'] == 'true';
 
 final bool SERIALIZED_COMPILATION =
     Platform.environment['SERIALIZED_COMPILATION'] == 'true';
 
 /// Mock URI used only in testing when [USE_SERIALIZED_DART_CORE] or
 /// [SERIALIZED_COMPILATION] is enabled.
-final Uri _SERIALIZED_URI = Uri.parse('file:fake.data');
+final Uri _SERIALIZED_DART_CORE_URI = Uri.parse('file:core.data');
+final Uri _SERIALIZED_TEST_URI = Uri.parse('file:test.data');
 
 void _useSerializedDataForDartCore(CompileFunc oldCompileFunc) {
   /// Run the [oldCompileFunc] with [serializedData] added as resolution input.
   Future<api.CompilationResult> compileWithSerializedData(
       CompilerOptions compilerOptions,
       api.CompilerInput compilerInput,
       api.CompilerDiagnostics compilerDiagnostics,
       api.CompilerOutput compilerOutput,
-      String serializedData) {
+      List<_SerializedData> serializedData) {
     api.CompilerInput input = compilerInput;
     CompilerOptions options = compilerOptions;
-    if (serializedData != null) {
-      input = new _CompilerInput(input, serializedData);
-      List<Uri> resolutionInputs = compilerOptions.resolutionInputs;
-      if (resolutionInputs == null) {
-        resolutionInputs = <Uri>[_SERIALIZED_URI];
-      } else if (!resolutionInputs.contains(_SERIALIZED_URI)) {
-        resolutionInputs = new List<Uri>.from(resolutionInputs)
-          ..add(_SERIALIZED_URI);
+    if (serializedData != null && serializedData.isNotEmpty) {
+      Map<Uri, String> dataMap = <Uri, String>{};
+      for (_SerializedData data in serializedData) {
+        dataMap[data.uri] = data.data;
+      }
+      input = new _CompilerInput(input, dataMap);
+      List<Uri> resolutionInputs = dataMap.keys.toList();
+      if (compilerOptions.resolutionInputs != null) {
+        for (Uri uri in compilerOptions.resolutionInputs) {
+          if (!dataMap.containsKey(uri)) {
+            resolutionInputs.add(uri);
+          }
+        }
       }
       options = options.copy(resolutionInputs: resolutionInputs);
     }
     return oldCompileFunc(options, input, compilerDiagnostics, compilerOutput);
   }
 
   /// Serialize [entryPoint] using [serializedData] if provided.
   Future<api.CompilationResult> serialize(
       Uri entryPoint,
+      Uri serializedUri,
       CompilerOptions compilerOptions,
       api.CompilerInput compilerInput,
       api.CompilerDiagnostics compilerDiagnostics,
       api.CompilerOutput compilerOutput,
-      [String serializedData]) {
+      [List<_SerializedData> serializedData]) {
     CompilerOptions options = new CompilerOptions.parse(
         entryPoint: entryPoint,
         libraryRoot: compilerOptions.libraryRoot,
         packageRoot: compilerOptions.packageRoot,
         packageConfig: compilerOptions.packageConfig,
         packagesDiscoveryProvider: compilerOptions.packagesDiscoveryProvider,
         environment: compilerOptions.environment,
-        resolutionOutput: _SERIALIZED_URI,
+        resolutionOutput: serializedUri,
         options: [Flags.resolveOnly]);
     return compileWithSerializedData(options, compilerInput,
         compilerDiagnostics, compilerOutput, serializedData);
   }
 
   // Local cache for the serialized data for dart:core.
-  String serializedDartCore;
+  _SerializedData serializedDartCore;
 
   /// Serialize the entry point using serialized data from dart:core and run
   /// [oldCompileFunc] using serialized data for whole program.
   Future<api.CompilationResult> compileFromSerializedData(
       CompilerOptions compilerOptions,
       api.CompilerInput compilerInput,
       api.CompilerDiagnostics compilerDiagnostics,
       api.CompilerOutput compilerOutput) async {
-    _CompilerOutput output = new _CompilerOutput();
+    _CompilerOutput output = new _CompilerOutput(_SERIALIZED_TEST_URI);
     api.CompilationResult result = await serialize(
         compilerOptions.entryPoint,
+        output.uri,
         compilerOptions,
         compilerInput,
         compilerDiagnostics,
         output,
-        serializedDartCore);
+        [serializedDartCore]);
     if (!result.isSuccess) {
       return result;
     }
-    return compileWithSerializedData(compilerOptions, compilerInput,
-        compilerDiagnostics, compilerOutput, output.serializedData);
+    return compileWithSerializedData(
+        compilerOptions,
+        compilerInput,
+        compilerDiagnostics,
+        compilerOutput,
+        [serializedDartCore, output.serializedData]);
   }
 
   /// Compiles the entry point using the serialized data from dart:core.
   Future<api.CompilationResult> compileWithSerializedDartCoreData(
       CompilerOptions compilerOptions,
       api.CompilerInput compilerInput,
       api.CompilerDiagnostics compilerDiagnostics,
       api.CompilerOutput compilerOutput) async {
     return compileWithSerializedData(compilerOptions, compilerInput,
-        compilerDiagnostics, compilerOutput, serializedDartCore);
+        compilerDiagnostics, compilerOutput, [serializedDartCore]);
   }
 
   /// Serialize dart:core data into [serializedDartCore] and setup the
   /// [compileFunc] to run the compiler using this data.
   Future<api.CompilationResult> generateSerializedDataForDartCore(
       CompilerOptions compilerOptions,
       api.CompilerInput compilerInput,
       api.CompilerDiagnostics compilerDiagnostics,
       api.CompilerOutput compilerOutput) async {
-    _CompilerOutput output = new _CompilerOutput();
-    await serialize(Uris.dart_core, compilerOptions, compilerInput,
+    _CompilerOutput output = new _CompilerOutput(_SERIALIZED_DART_CORE_URI);
+    await serialize(Uris.dart_core, output.uri, compilerOptions, compilerInput,
         compilerDiagnostics, output);
     serializedDartCore = output.serializedData;
     if (SERIALIZED_COMPILATION) {
       compileFunc = compileFromSerializedData;
     } else {
       compileFunc = compileWithSerializedDartCoreData;
     }
     return compileFunc(
         compilerOptions, compilerInput, compilerDiagnostics, compilerOutput);
   }
 
   compileFunc = generateSerializedDataForDartCore;
 }
 
 class _CompilerInput implements api.CompilerInput {
   final api.CompilerInput _input;
-  final String _data;
+  final Map<Uri, String> _data;
 
   _CompilerInput(this._input, this._data);
 
   @override
   Future readFromUri(Uri uri) {
-    if (uri == _SERIALIZED_URI) {
-      return new Future.value(_data);
+    String data = _data[uri];
+    if (data != null) {
+      return new Future.value(data);
     }
     return _input.readFromUri(uri);
   }
 }
 
+class _SerializedData {
+  final Uri uri;
+  final String data;
+
+  _SerializedData(this.uri, this.data);
+}
+
 class _CompilerOutput extends NullCompilerOutput {
+  final Uri uri;
   _BufferedEventSink sink;
 
+  _CompilerOutput(this.uri);
+
   @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();
+  _SerializedData get serializedData {
+    return new _SerializedData(uri, 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
   }
 }