[dart2wasm] Introduce an opt phase to dart2wasm.

To help facilitate this we move all IO into a separate helper
library/class. This makes it easier to have symmetric read/write
functions and to do IO within compile.dart where necessary.

Adding the new `opt` phase allows us to remove the duplicated code
between dartdev and compile_benchmark simplifying those two files a lot.
It will also allow us to more easily invoke wasm-opt within our internal
build pipeline.

For compile_benchmark we still run the opt phase independently (but
through dart2wasm) to keep the benchmark data as consistent as possible.

Change-Id: Iaa855dbc3a05abfedbc3eea4af32e3ba27e84600
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/464640
Commit-Queue: Nate Biggs <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>

Author: natebiggs

pkg/dart2wasm/benchmark/self_compile_benchmark.dart

@@ -2,41 +2,70 @@
 // 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.
 
+import 'dart:typed_data';
+
 import 'package:_fe_analyzer_shared/src/util/colors.dart' as colors;
 import 'package:dart2wasm/compile.dart';
 import 'package:dart2wasm/compiler_options.dart';
+import 'package:dart2wasm/io_util.dart';
 
 import 'filesystem_io.dart' if (dart.library.js_interop) 'filesystem_js.dart';
 
+class _BenchmarkIOManager extends CompilerPhaseInputOutputManager {
+  final WasmCompilerFileSystem benchmarkFileSystem;
+  Uint8List? moduleBytes;
+
+  _BenchmarkIOManager(this.benchmarkFileSystem, WasmCompilerOptions options)
+      : super(benchmarkFileSystem, options);
+
+  @override
+  Future<void> writeWasmModule(Uint8List wasmModule, String moduleName) async {
+    moduleBytes = wasmModule;
+  }
+
+  @override
+  Future<void> writeWasmSourceMap(String sourceMap, String moduleName) async {}
+
+  @override
+  Future<void> writeJsRuntime(String jsRuntime) async {}
+
+  @override
+  Future<void> writeSupportJs(String supportJs) async {}
+
+  void flushWasmModules(String wasmFile) {
+    benchmarkFileSystem.writeBytesSync(wasmFile, moduleBytes!);
+  }
+}
+
 Future main(List<String> args) async {
   final sw = Stopwatch()..start();
   final fileSystem = WasmCompilerFileSystem();
-  final result = await compileBenchmark(
-      fileSystem, 'pkg/dart2wasm/benchmark/self_compile_benchmark.dart');
+  final mainFile = 'pkg/dart2wasm/benchmark/self_compile_benchmark.dart';
+  final main = Uri.file('${fileSystem.sdkRoot}/$mainFile');
+
+  final options = WasmCompilerOptions(mainUri: main, outputFile: 'out.wasm');
+  final ioManager = _BenchmarkIOManager(fileSystem, options);
+
+  options.librariesSpecPath =
+      Uri.file('${fileSystem.sdkRoot}/sdk/lib/libraries.json');
+
+  await compileBenchmark(options, ioManager);
   print('Dart2WasmSelfCompile(RunTimeRaw): ${sw.elapsed.inMilliseconds} ms.');
 
   if (args.isNotEmpty) {
-    final module = result.wasmModules.values.single;
     final wasmFile = args.single;
-    fileSystem.writeBytesSync(wasmFile, module.moduleBytes);
+    ioManager.flushWasmModules(wasmFile);
   }
 }
 
-Future<CodegenResult> compileBenchmark(
-    WasmCompilerFileSystem fileSystem, String mainFile) async {
+Future<CodegenResult> compileBenchmark(WasmCompilerOptions options,
+    CompilerPhaseInputOutputManager ioManager) async {
   // Avoid CFE self-detecting whether `stdout`/`stderr` is terminal and supports
   // colors (as we don't have `dart:io` available when we run dart2wasm in a
   // wasm runtime).
   colors.enableColors = false;
 
-  final main = Uri.file('${fileSystem.sdkRoot}/$mainFile');
-
-  final options = WasmCompilerOptions(mainUri: main, outputFile: 'out.wasm');
-  options.librariesSpecPath =
-      Uri.file('${fileSystem.sdkRoot}/sdk/lib/libraries.json');
-
-  final result = await compile(
-      options, fileSystem, (mod) => Uri.parse('$mod.maps'), (diag) {
+  final result = await compile(options, ioManager, (diag) {
     print('Diagnostics: ${diag.severity} ${diag.plainTextFormatted}');
   });
   if (result is! CompilationSuccess) {