[dart2bytecode] Add API to invoke dart2bytecode programmatically

TEST=ci
Bug: b/394206952
Change-Id: Icd606c83bfed335e45498fceed6add784c465826
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/407820
Reviewed-by: Jia Hao Goh <[email protected]>
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

pkg/dart2bytecode/lib/dart2bytecode.dart

@@ -97,12 +97,13 @@ ${_argParser.usage}
 ''';
 
 Future<void> main(List<String> arguments) async {
-  io.exitCode = await runCompiler(_argParser.parse(arguments));
+  io.exitCode = await runCompilerWithCommandLineArguments(arguments);
 }
 
-/// Run bytecode compiler tool with given [options]
-/// and return exit code.
-Future<int> runCompiler(ArgResults options) async {
+/// Run bytecode compiler tool with given [arguments]
+/// and return exit code (0 on success, non-zero on failure).
+Future<int> runCompilerWithCommandLineArguments(List<String> arguments) async {
+  final ArgResults options = _argParser.parse(arguments);
   final String? platformKernel = options['platform'];
 
   if (options['help']) {
@@ -131,6 +132,58 @@ Future<int> runCompiler(ArgResults options) async {
     return badUsageExitCode;
   }
 
+  final String? importDill = options['import-dill'];
+  final String? validateDynamicInterface = options['validate'];
+  final String messageVerbosity = options['verbosity'];
+  final String cfeInvocationModes = options['invocation-modes'];
+  final bool trackWidgetCreation = options['track-widget-creation'];
+  final List<String>? bytecodeGeneratorOptions = options['bytecode-options'];
+
+  return await runCompilerWithOptions(
+    input: input,
+    platformKernel: platformKernel,
+    outputFileName: outputFileName,
+    targetName: targetName,
+    packages: packages,
+    importDill: importDill,
+    validateDynamicInterface: validateDynamicInterface,
+    enableAsserts: enableAsserts,
+    experimentalFlags: experimentalFlags,
+    environmentDefines: environmentDefines,
+    fileSystemScheme: fileSystemScheme,
+    fileSystemRoots: fileSystemRoots,
+    messageVerbosity: messageVerbosity,
+    cfeInvocationModes: cfeInvocationModes,
+    trackWidgetCreation: trackWidgetCreation,
+    bytecodeGeneratorOptions: bytecodeGeneratorOptions,
+    depfile: depfile,
+    depfileTarget: depfileTarget,
+  );
+}
+
+/// Run bytecode compiler tool with given options
+/// and return exit code (0 on success, non-zero on failure).
+Future<int> runCompilerWithOptions({
+  required String input,
+  required String platformKernel,
+  required String outputFileName,
+  required String targetName,
+  String? packages,
+  String? importDill,
+  String? validateDynamicInterface,
+  bool enableAsserts = false,
+  List<String>? experimentalFlags,
+  Map<String, String> environmentDefines = const {},
+  String? fileSystemScheme,
+  List<String>? fileSystemRoots,
+  String messageVerbosity = Verbosity.defaultValue,
+  void Function(String) printMessage = print,
+  String cfeInvocationModes = '',
+  bool trackWidgetCreation = false,
+  List<String>? bytecodeGeneratorOptions,
+  String? depfile,
+  String? depfileTarget,
+}) async {
   final fileSystem =
       createFrontEndFileSystem(fileSystemScheme, fileSystemRoots);
 
@@ -139,17 +192,17 @@ Future<int> runCompiler(ArgResults options) async {
   final platformKernelUri = Uri.base.resolveUri(new Uri.file(platformKernel));
 
   final List<Uri> additionalDills = <Uri>[];
-  final String? importDill = options['import-dill'];
   if (importDill != null) {
     additionalDills.add(Uri.base.resolveUri(new Uri.file(importDill)));
   }
 
-  final String? validate = options['validate'];
   final Uri? dynamicInterfaceSpecificationUri =
-      (validate != null) ? resolveInputUri(validate) : null;
+      (validateDynamicInterface != null)
+          ? resolveInputUri(validateDynamicInterface)
+          : null;
 
-  final verbosity = Verbosity.parseArgument(options['verbosity']);
-  final errorPrinter = ErrorPrinter(verbosity);
+  final verbosity = Verbosity.parseArgument(messageVerbosity);
+  final errorPrinter = ErrorPrinter(verbosity, println: printMessage);
   final errorDetector = ErrorDetector(previousErrorHandler: errorPrinter.call);
 
   Uri mainUri = resolveInputUri(input);
@@ -165,20 +218,18 @@ Future<int> runCompiler(ArgResults options) async {
     ..dynamicInterfaceSpecificationUri = dynamicInterfaceSpecificationUri
     ..explicitExperimentalFlags = parseExperimentalFlags(
         parseExperimentalArguments(experimentalFlags),
-        onError: print)
+        onError: printMessage)
     ..onDiagnostic = (DiagnosticMessage m) {
       errorDetector(m);
     }
     ..embedSourceText = false
-    ..invocationModes =
-        InvocationMode.parseArguments(options['invocation-modes'])
+    ..invocationModes = InvocationMode.parseArguments(cfeInvocationModes)
     ..verbosity = verbosity;
 
   compilerOptions.target = createFrontEndTarget(targetName,
-      trackWidgetCreation: options['track-widget-creation'],
-      supportMirrors: false);
+      trackWidgetCreation: trackWidgetCreation, supportMirrors: false);
   if (compilerOptions.target == null) {
-    print('Failed to create front-end target $targetName.');
+    printMessage('Failed to create front-end target $targetName.');
     return badUsageExitCode;
   }
 
@@ -187,7 +238,7 @@ Future<int> runCompiler(ArgResults options) async {
       options: compilerOptions,
       requireMain: false,
       includePlatform: false,
-      environmentDefines: environmentDefines,
+      environmentDefines: Map.of(environmentDefines),
       enableAsserts: enableAsserts));
 
   errorPrinter.printCompilationMessages();
@@ -199,7 +250,7 @@ Future<int> runCompiler(ArgResults options) async {
 
   final BytecodeOptions bytecodeOptions =
       BytecodeOptions(enableAsserts: enableAsserts)
-        ..parseCommandLineFlags(options['bytecode-options']);
+        ..parseCommandLineFlags(bytecodeGeneratorOptions);
 
   if (bytecodeOptions.showBytecodeSizeStatistics) {
     BytecodeSizeStatistics.reset();

pkg/vm/lib/kernel_front_end.dart

@@ -433,7 +433,9 @@ class KernelCompilationResults {
   final Iterable<Uri>? compiledSources;
   final Uri? usedPackageConfig;
 
-  KernelCompilationResults(this.component, this.loadedLibraries,
+  KernelCompilationResults(
+    this.component,
+    this.loadedLibraries,
     this.classHierarchy,
     this.coreTypes,
     this.compiledSources,
@@ -540,9 +542,9 @@ Future<KernelCompilationResults> compileToKernel(
     compilerResult = await CompilerContext.runWithOptions(processedOptions,
         (CompilerContext context) async {
       return args.requireMain
-        ? await kernelForProgram(args.source!, options,
-            additionalSources: args.additionalSources)
-        : await kernelForModule(
+          ? await kernelForProgram(args.source!, options,
+              additionalSources: args.additionalSources)
+          : await kernelForModule(
               [args.source!, ...args.additionalSources], options);
     });
     usedPackageConfig = await processedOptions.resolvePackagesFileUri();
@@ -724,8 +726,10 @@ class ErrorPrinter {
   final DiagnosticMessageHandler? previousErrorHandler;
   final Map<Uri?, List<DiagnosticMessage>> compilationMessages =
       <Uri?, List<DiagnosticMessage>>{};
+  final void Function(String) println;
 
-  ErrorPrinter(this.verbosity, {this.previousErrorHandler});
+  ErrorPrinter(this.verbosity,
+      {this.previousErrorHandler, this.println = print});
 
   void call(DiagnosticMessage message) {
     final sourceUri = getMessageUri(message);
@@ -750,7 +754,7 @@ class ErrorPrinter {
     for (final Uri? sourceUri in sortedUris) {
       for (final DiagnosticMessage message in compilationMessages[sourceUri]!) {
         if (Verbosity.shouldPrint(verbosity, message)) {
-          printDiagnosticMessage(message, print);
+          printDiagnosticMessage(message, println);
         }
       }
     }