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;
 
 import 'package:package_config/discovery.dart' show findPackages;
 
-import '../compiler.dart' as api;
+import '../compiler_new.dart' as api;
 import 'commandline_options.dart';
 import 'filenames.dart';
 import 'io/source_file.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';
 
 /**
  * A string to identify the revision or build.
@@ skipping 70 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 52 matching lines @@
 
   if (checkedMode && trustTypeAnnotations) {
     helpAndFail("Option '${Flags.trustTypeAnnotations}' may not be used in "
         "checked mode.");
   }
 
   if (packageRoot != null && packageConfig != null) {
     helpAndFail("Cannot specify both '--package-root' and '--packages.");
   }
 
-  if ((analyzeOnly || analyzeAll) && !optionsImplyCompilation.isEmpty) {
-    if (!analyzeOnly) {
+  if ((analyzeOnly || analyzeAll || serializationTarget != null) &&
+      !optionsImplyCompilation.isEmpty) {
+    if (serializationTarget != null) {
+      if (!analyzeAll) {
+        diagnosticHandler.info(
+            "Option '${Option.serializationTarget}' implies "
+            "'${Flags.analyzeAll}'.",
+            api.Diagnostic.INFO);
+        analyzeAll = true;
+      }

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

maybe set analyzeOnly here too?

That way we don't report a chain of warnings like:

  Option --serialization-target implies --analyze-all
  Option --analyze-all implies --analyze-only

:)

[Johnni Winther, 2016/05/18 09:52:41]

Done.

+    }
+    if (analyzeAll && !analyzeOnly) {
       diagnosticHandler.info(
           "Option '${Flags.analyzeAll}' implies '${Flags.analyzeOnly}'.",
           api.Diagnostic.INFO);
     }
     diagnosticHandler.info(
         "Options $optionsImplyCompilation indicate that output is expected, "
         "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 (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 '
             '-> ${outputProvider.totalCharactersWritten} characters '
             '$outputLanguage in '
             '${relativize(currentDirectory, out, Platform.isWindows)}');
     if (diagnosticHandler.verbose) {
       String input = uriPathToNative(arguments[0]);
       print('Dart file ($input) compiled to $outputLanguage.');
       print('Wrote the following files:');
       for (String filename in outputProvider.allOutputFiles) {
         print("  $filename");
       }
     } else if (!explicitOut) {
       String input = uriPathToNative(arguments[0]);
       String output = relativize(currentDirectory, out, Platform.isWindows);
       print('Dart file ($input) compiled to $outputLanguage: $output');
     }
     return result;
   }
 
-  Uri uri = currentDirectory.resolve(arguments[0]);
+  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(
-          uri,
-          libraryRoot,
-          packageRoot,
-          inputProvider,
-          diagnosticHandler,
-          options,
-          outputProvider,
-          environment,
-          packageConfig,
-          findPackages)
+          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 190 matching lines @@
 void main(List<String> arguments) {
   // Since the sdk/bin/dart2js script adds its own arguments in front of
   // user-supplied arguments we search for '--batch' at the end of the list.
   if (arguments.length > 0 && arguments.last == "--batch") {
     batchMain(arguments.sublist(0, arguments.length - 1));
     return;
   }
   internalMain(arguments);
 }
 
-var exitFunc = exit;
-var compileFunc = api.compile;
+typedef void ExitFunc(int exitCode);
+typedef Future<api.CompilationResult> CompileFunc(
+    CompilerOptions compilerOptions,
+    api.CompilerInput compilerInput,
+    api.CompilerDiagnostics compilerDiagnostics,
+    api.CompilerOutput compilerOutput);
+
+ExitFunc exitFunc = exit;
+CompileFunc compileFunc = api.compile;
 
 Future<api.CompilationResult> internalMain(List<String> arguments) {
   Future onError(exception, trace) {
     // If we are already trying to exit, just continue exiting.
     if (exception == _EXIT_SIGNAL) throw exception;
 
     try {
       print('The compiler crashed: $exception');
     } catch (ignored) {
       print('The compiler crashed: error while printing exception');
@@ skipping 56 matching lines @@
       } else if (exitCode == 253) {
         print(">>> TEST CRASH");
       } else {
         print(">>> TEST FAIL");
       }
       stderr.writeln(">>> EOF STDERR");
       subscription.resume();
     });
   });
 }