[dart2wasm] Reduce base overhead of hello world

Currently we perform a type check of the `main` method
against several function types at runtime to determine
which version to use when invoking the user-written `main`
method.

This CL moves those checks to compile-time as we have the function type
of the user-written `main` method available at compile time.

This reduces the most simple hello world

  main() => print('hello world');

from 12 KB to 4 KB in -O4 mode.

Change-Id: Icf49a1396e808274ac452c528b407a8bd1ef4bf6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/415440
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Ömer Ağacan <[email protected]>

Author: mkustermann

pkg/dart2wasm/lib/compile.dart

@@ -22,6 +22,7 @@ import 'package:kernel/core_types.dart';
 import 'package:kernel/kernel.dart'
     show writeComponentToBinary, writeComponentToText;
 import 'package:kernel/library_index.dart';
+import 'package:kernel/type_environment.dart';
 import 'package:kernel/verifier.dart';
 import 'package:path/path.dart' as path show setExtension;
 import 'package:vm/kernel_front_end.dart' show writeDepfile;
@@ -273,14 +274,7 @@ Future<CompilationResult> compileToModule(
         includeSource: false);
   }
 
-  // Patch `dart:_internal`s `mainTearOff` getter.
-  final internalLib = component.libraries
-      .singleWhere((lib) => lib.importUri.toString() == 'dart:_internal');
-  final mainTearOff = internalLib.procedures
-      .singleWhere((procedure) => procedure.name.text == 'mainTearOff');
-  mainTearOff.isExternal = false;
-  mainTearOff.function.body = ReturnStatement(
-      ConstantExpression(StaticTearOffConstant(component.mainMethod!)));
+  _patchMainTearOffs(coreTypes, component);
 
   // Keep the flags in-sync with
   // pkg/vm/test/transformations/type_flow/transformer_test.dart
@@ -353,6 +347,38 @@ Future<CompilationResult> compileToModule(
   return CompilationSuccess(wasmModules, jsRuntime, supportJs);
 }
 
+// Patches `dart:_internal`s `mainTearOff{0,1,2}` getters.
+void _patchMainTearOffs(CoreTypes coreTypes, Component component) {
+  final mainMethod = component.mainMethod!;
+  final mainMethodType = mainMethod.computeSignatureOrFunctionType();
+  void patchToReturnMainTearOff(Procedure p) {
+    p.function.body =
+        ReturnStatement(ConstantExpression(StaticTearOffConstant(mainMethod)))
+          ..parent = p.function;
+  }
+
+  final typeEnv =
+      TypeEnvironment(coreTypes, ClassHierarchy(component, coreTypes));
+  bool mainHasType(DartType type) => typeEnv.isSubtypeOf(
+      mainMethodType, type, SubtypeCheckMode.withNullabilities);
+
+  final internalLib = coreTypes.index.getLibrary('dart:_internal');
+  (Procedure, DartType) lookupAndInitialize(String name) {
+    final p = internalLib.procedures
+        .singleWhere((procedure) => procedure.name.text == name);
+    p.isExternal = false;
+    p.function.body = ReturnStatement(NullLiteral())..parent = p.function;
+    return (p, p.function.returnType.toNonNull());
+  }
+
+  final (mainTearOff0, mainArg0Type) = lookupAndInitialize('mainTearOffArg0');
+  final (mainTearOff1, mainArg1Type) = lookupAndInitialize('mainTearOffArg1');
+  final (mainTearOff2, mainArg2Type) = lookupAndInitialize('mainTearOffArg2');
+  if (mainHasType(mainArg2Type)) return patchToReturnMainTearOff(mainTearOff2);
+  if (mainHasType(mainArg1Type)) return patchToReturnMainTearOff(mainTearOff1);
+  if (mainHasType(mainArg0Type)) return patchToReturnMainTearOff(mainTearOff0);
+}
+
 String _generateSupportJs(TranslatorOptions options) {
   // Copied from
   // https://github.com/GoogleChromeLabs/wasm-feature-detect/blob/main/src/detectors/gc/index.js

sdk/lib/_internal/wasm/lib/internal_patch.dart

@@ -121,25 +121,34 @@ external int doubleToIntBits(double value);
 external double intBitsToDouble(int value);
 
 // Will be patched in `pkg/dart2wasm/lib/compile.dart` right before TFA.
-external Function get mainTearOff;
+external void Function()? get mainTearOffArg0;
+external void Function(List<String>)? get mainTearOffArg1;
+external void Function(List<String>, Null)? get mainTearOffArg2;
 
 /// Used to invoke the `main` function from JS, printing any exceptions that
 /// escape.
 @pragma("wasm:export", "\$invokeMain")
 void _invokeMain(WasmExternRef jsArrayRef) {
   try {
-    final jsArray = (JSValue(jsArrayRef) as JSArray<JSString>).toDart;
-    final args = <String>[for (final jsValue in jsArray) jsValue.toDart];
-    final main = mainTearOff;
-    if (main is void Function(List<String>, Null)) {
-      main(List.unmodifiable(args), null);
-    } else if (main is void Function(List<String>)) {
-      main(List.unmodifiable(args));
-    } else if (main is void Function()) {
-      main();
-    } else {
-      throw "Could not call main";
+    // We will only compile one of these cases, the remaining cases will be
+    // eliminated by the compiler.
+    if (mainTearOffArg0 case final mainMethod?) {
+      mainMethod();
+      return;
+    }
+    if (mainTearOffArg1 case final mainMethod?) {
+      final jsArray = (JSValue(jsArrayRef) as JSArray<JSString>).toDart;
+      final args = <String>[for (final jsValue in jsArray) jsValue.toDart];
+      mainMethod(List.unmodifiable(args));
+      return;
+    }
+    if (mainTearOffArg2 case final mainMethod?) {
+      final jsArray = (JSValue(jsArrayRef) as JSArray<JSString>).toDart;
+      final args = <String>[for (final jsValue in jsArray) jsValue.toDart];
+      mainMethod(List.unmodifiable(args), null);
+      return;
     }
+    throw "Could not call main";
   } catch (e, s) {
     print(e);
     print(s);