Support (de)serialization from command-line

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:convert' show UTF8, LineSplitter;
 import 'dart:io' show exit, File, FileMode, Platform, stdin, stderr;
 
@@ skipping 87 matching lines @@
   }
 }
 
 FormattingDiagnosticHandler diagnosticHandler;
 
 Future<api.CompilationResult> compile(List<String> argv) {
   stackTraceFilePrefix = '$currentDirectory';
   Uri libraryRoot = currentDirectory;
   Uri out = currentDirectory.resolve('out.js');
   Uri sourceMapOut = currentDirectory.resolve('out.js.map');
+  Uri serializationSource;
+  Uri serializationTarget;
   Uri packageConfig = null;
   Uri packageRoot = null;
   List<String> options = new List<String>();
   bool explicitOut = false;
   bool wantHelp = false;
   bool wantVersion = false;
   String outputLanguage = 'JavaScript';
   bool stripArgumentSet = false;
   bool analyzeOnly = false;
   bool analyzeAll = false;
   bool dumpInfo = false;
   bool allowNativeExtensions = false;
   bool trustTypeAnnotations = false;
   bool trustJSInteropTypeAnnotations = false;
   bool checkedMode = false;
   // List of provided options that imply that output is expected.
   List<String> optionsImplyCompilation = <String>[];
   bool hasDisallowUnsafeEval = false;
   // TODO(johnniwinther): Measure time for reading files.
   SourceFileProvider inputProvider = new CompilerSourceFileProvider();
   diagnosticHandler = new FormattingDiagnosticHandler(inputProvider);
   Map<String, dynamic> environment = new Map<String, dynamic>();
 
-  passThrough(String argument) => options.add(argument);
+  void passThrough(String argument) => options.add(argument);
 
   if (BUILD_ID != null) {
     passThrough("--build-id=$BUILD_ID");
   }
 
-  setLibraryRoot(String argument) {
+  void setLibraryRoot(String argument) {
     libraryRoot = currentDirectory.resolve(extractPath(argument));
   }
 
-  setPackageRoot(String argument) {
+  void setPackageRoot(String argument) {
     packageRoot = currentDirectory.resolve(extractPath(argument));
   }
 
-  setPackageConfig(String argument) {
+  void setPackageConfig(String argument) {
     packageConfig =
         currentDirectory.resolve(extractPath(argument, isDirectory: false));
   }
 
-  setOutput(Iterator<String> arguments) {
+  void setOutput(Iterator<String> arguments) {
     optionsImplyCompilation.add(arguments.current);
     String path;
     if (arguments.current == '-o') {
       if (!arguments.moveNext()) {
         helpAndFail('Error: Missing file after -o option.');
       }
       path = arguments.current;
     } else {
       path = extractParameter(arguments.current);
     }
     explicitOut = true;
     out = currentDirectory.resolve(nativeToUriPath(path));
     sourceMapOut = Uri.parse('$out.map');
   }
 
-  setOutputType(String argument) {
+  void setOutputType(String argument) {
     optionsImplyCompilation.add(argument);
     if (argument == '--output-type=dart' ||
         argument == '--output-type=dart-multi') {
       outputLanguage = OUTPUT_LANGUAGE_DART;
       if (!explicitOut) {
         out = currentDirectory.resolve('out.dart');
         sourceMapOut = currentDirectory.resolve('out.dart.map');
       }
       diagnosticHandler(
           null,
           null,
           null,
           "--output-type=dart is deprecated. It will remain available "
           "in Dart 1.11, but will be removed in Dart 1.12.",
           api.Diagnostic.WARNING);
     }
     passThrough(argument);
   }
 
+  void setSerializationSource(String argument) {
+    serializationSource =
+        currentDirectory.resolve(extractPath(argument, isDirectory: false));
+  }
+
+  void setSerializationTarget(String argument) {
+    serializationTarget =
+        currentDirectory.resolve(extractPath(argument, isDirectory: false));
+  }
+
   String getDepsOutput(Map<Uri, SourceFile> sourceFiles) {
     var filenames = sourceFiles.keys.map((uri) => '$uri').toList();
     filenames.sort();
     return filenames.join("\n");
   }
 
-  setStrip(String argument) {
+  void setStrip(String argument) {
     optionsImplyCompilation.add(argument);
     stripArgumentSet = true;
     passThrough(argument);
   }
 
-  setAnalyzeOnly(String argument) {
+  void setAnalyzeOnly(String argument) {
     analyzeOnly = true;
     passThrough(argument);
   }
 
-  setAnalyzeAll(String argument) {
+  void setAnalyzeAll(String argument) {
     analyzeAll = true;
     passThrough(argument);
   }
 
-  setAllowNativeExtensions(String argument) {
+  void setAllowNativeExtensions(String argument) {
     allowNativeExtensions = true;
     passThrough(argument);
   }
 
-  setVerbose(_) {
+  void setVerbose(_) {
     diagnosticHandler.verbose = true;
     passThrough('--verbose');
   }
 
-  implyCompilation(String argument) {
+  void implyCompilation(String argument) {
     optionsImplyCompilation.add(argument);
     passThrough(argument);
   }
 
-  setDumpInfo(String argument) {
+  void setDumpInfo(String argument) {
     implyCompilation(argument);
     dumpInfo = true;
   }
 
-  setTrustTypeAnnotations(String argument) {
+  void setTrustTypeAnnotations(String argument) {
     trustTypeAnnotations = true;
     implyCompilation(argument);
   }
 
-  setTrustJSInteropTypeAnnotations(String argument) {
+  void setTrustJSInteropTypeAnnotations(String argument) {
     trustJSInteropTypeAnnotations = true;
     implyCompilation(argument);
   }
 
-  setTrustPrimitives(String argument) {
+  void setTrustPrimitives(String argument) {
     implyCompilation(argument);
   }
 
-  setCheckedMode(String argument) {
+  void setCheckedMode(String argument) {
     checkedMode = true;
     passThrough(argument);
   }
 
-  addInEnvironment(String argument) {
+  void addInEnvironment(String argument) {
     int eqIndex = argument.indexOf('=');
     String name = argument.substring(2, eqIndex);
     String value = argument.substring(eqIndex + 1);
     environment[name] = value;
   }
 
-  setCategories(String argument) {
+  void setCategories(String argument) {
     List<String> categories = extractParameter(argument).split(',');
     if (categories.contains('all')) {
       categories = ["Client", "Server"];
     } else {
       for (String category in categories) {
         if (!["Client", "Server"].contains(category)) {
           fail('Unsupported library category "$category", '
               'supported categories are: Client, Server, all');
         }
       }
     }
     passThrough('--categories=${categories.join(",")}');
   }
 
   void handleThrowOnError(String argument) {
     diagnosticHandler.throwOnError = true;
     String parameter = extractParameter(argument, isOptionalArgument: true);
     if (parameter != null) {
       diagnosticHandler.throwOnErrorCount = int.parse(parameter);
     }
   }
 
-  handleShortOptions(String argument) {
+  void handleShortOptions(String argument) {
     var shortOptions = argument.substring(1).split("");
     for (var shortOption in shortOptions) {
       switch (shortOption) {
         case 'v':
           setVerbose(null);
           break;
         case 'h':
         case '?':
           wantHelp = true;
           break;
@@ skipping 48 matching lines @@
     new OptionHandler(
         Flags.trustJSInteropTypeAnnotations,
         (_) => setTrustJSInteropTypeAnnotations(
             Flags.trustJSInteropTypeAnnotations)),
     new OptionHandler(r'--help|/\?|/h', (_) => wantHelp = true),
     new OptionHandler('--packages=.+', setPackageConfig),
     new OptionHandler('--package-root=.+|-p.+', setPackageRoot),
     new OptionHandler(Flags.analyzeAll, setAnalyzeAll),
     new OptionHandler(Flags.analyzeOnly, setAnalyzeOnly),
     new OptionHandler(Flags.noSourceMaps, passThrough),
+    new OptionHandler(Option.serializationSource, setSerializationSource),
+    new OptionHandler(Option.serializationTarget, setSerializationTarget),
     new OptionHandler(Flags.analyzeSignaturesOnly, setAnalyzeOnly),
     new OptionHandler(Flags.disableNativeLiveTypeAnalysis, passThrough),
     new OptionHandler('--categories=.*', setCategories),
     new OptionHandler(Flags.disableTypeInference, implyCompilation),
     new OptionHandler(Flags.terse, passThrough),
     new OptionHandler('--deferred-map=.+', implyCompilation),
     new OptionHandler(Flags.dumpInfo, setDumpInfo),
     new OptionHandler(
         '--disallow-unsafe-eval', (_) => hasDisallowUnsafeEval = true),
     new OptionHandler(Option.showPackageWarnings, passThrough),
     new OptionHandler(Flags.useContentSecurityPolicy, passThrough),
     new OptionHandler(Flags.enableExperimentalMirrors, passThrough),
     new OptionHandler(Flags.enableAssertMessage, passThrough),
+
     // TODO(floitsch): remove conditional directives flag.
     // We don't provide the info-message yet, since we haven't publicly
     // launched the feature yet.
     new OptionHandler(Flags.conditionalDirectives, (_) {}),
     new OptionHandler('--enable-async', (_) {
       diagnosticHandler.info(
           "Option '--enable-async' is no longer needed. "
           "Async-await is supported by default.",
           api.Diagnostic.HINT);
     }),
@@ skipping 70 matching lines @@
         "but compilation is turned off by the option '${Flags.analyzeOnly}'.",
         api.Diagnostic.INFO);
   }
   if (analyzeAll) analyzeOnly = true;
   if (!analyzeOnly) {
     if (allowNativeExtensions) {
       helpAndFail("Option '${Flags.allowNativeExtensions}' is only supported "
           "in combination with the '${Flags.analyzeOnly}' option.");
     }
   }
+  if (!analyzeAll) {
+    if (serializationTarget != null) {
+      helpAndFail("Option '${Option.serializationTarget}' is only supported "

[Siggi Cherem (dart-lang), 2016/05/14 01:10:31]

I'd be OK implying it (instead of requiring that we have to write --analyze-all
as well.)

[Johnni Winther, 2016/05/17 12:37:33]

Done.

+          "in combination with the '${Flags.analyzeAll}' option.");
+    }
+  }
   if (dumpInfo && outputLanguage == OUTPUT_LANGUAGE_DART) {
     helpAndFail("Option '${Flags.dumpInfo}' is not supported in "
         "combination with the '--output-type=dart' option.");
   }
 
   options.add('--out=$out');
   options.add('--source-map=$sourceMapOut');
 
   RandomAccessFileOutputProvider outputProvider =
       new RandomAccessFileOutputProvider(out, sourceMapOut,
-          onInfo: diagnosticHandler.info, onFailure: fail);
+          onInfo: diagnosticHandler.info,
+          onFailure: fail,
+          serializationTarget: serializationTarget);
 
   api.CompilationResult compilationDone(api.CompilationResult result) {
     if (analyzeOnly) return result;
     if (!result.isSuccess) {
       fail('Compilation failed.');
     }
     writeString(
         Uri.parse('$out.deps'), getDepsOutput(inputProvider.sourceFiles));
     diagnosticHandler
         .info('Compiled ${inputProvider.dartCharactersRead} characters Dart '
@@ skipping 15 matching lines @@
     return result;
   }
 
   Uri script = currentDirectory.resolve(arguments[0]);
   CompilerOptions compilerOptions = new CompilerOptions.parse(
       entryPoint: script,
       libraryRoot: libraryRoot,
       packageRoot: packageRoot,
       packageConfig: packageConfig,
       packagesDiscoveryProvider: findPackages,
+      serializationSource: serializationSource,
+      serializationTarget: serializationTarget,
       options: options,
       environment: environment);
-  return compileFunc(compilerOptions, inputProvider, 
-    diagnosticHandler, outputProvider)
+  return compileFunc(
+          compilerOptions, inputProvider, diagnosticHandler, outputProvider)
       .then(compilationDone);
 }
 
 class AbortLeg {
   final message;
   AbortLeg(this.message);
   toString() => 'Aborted due to --throw-on-error: $message';
 }
 
 void writeString(Uri uri, String text) {
@@ skipping 275 matching lines @@
       } else if (exitCode == 253) {
         print(">>> TEST CRASH");
       } else {
         print(">>> TEST FAIL");
       }
       stderr.writeln(">>> EOF STDERR");
       subscription.resume();
     });
   });
 }