[dart2js] Add support for tree shaking protobuf messages with mixins.

Typically these mixins introduce additional reflective features on the messages extending them. This made it unfavorable to tree shake fields on these messages.

However, some customers have tooling that makes it so the set of messages/fields accessed reflectively through mixins is statically known. Therefore, they can inject special code to retain those messages/fields and still benefit from treeshaking on the rest of the fields in those messages.

This is a separate flag because it introduces new opportunities for breakages that users may want to roll out separately.

Testing on an internal build showed an additional ~2.8% code size reduction from this additional tree shaking.

Change-Id: I6bbe6209acc26f8e8904c81f6960b71e4b516f25
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/414820
Reviewed-by: Mayank Patke <[email protected]>
Commit-Queue: Nate Biggs <[email protected]>

Author: natebiggs

pkg/compiler/lib/src/commandline_options.dart

@@ -77,6 +77,7 @@ class Flags {
   static const String laxRuntimeTypeToString = '--lax-runtime-type-to-string';
 
   static const String enableProtoShaking = '--enable-proto-shaking';
+  static const String enableProtoMixinShaking = '--enable-proto-mixin-shaking';
 
   static const String platformBinaries = '--platform-binaries=.+';
 

pkg/compiler/lib/src/dart2js.dart

@@ -514,6 +514,7 @@ Future<api.CompilationResult> compile(
     _OneOption(Flags.omitAsCasts, passThrough),
     _OneOption(Flags.laxRuntimeTypeToString, passThrough),
     _OneOption(Flags.enableProtoShaking, passThrough),
+    _OneOption(Flags.enableProtoMixinShaking, passThrough),
     _OneOption(Flags.benchmarkingProduction, passThrough),
     _OneOption(Flags.benchmarkingExperiment, passThrough),
     _OneOption(Flags.soundNullSafety, passThrough),

pkg/compiler/lib/src/ir/protobuf_impacts.dart

@@ -73,24 +73,55 @@ import 'impact_data.dart';
 class ProtobufImpactHandler implements ConditionalImpactHandler {
   static const String protobufLibraryUri = 'package:protobuf/protobuf.dart';
 
+  static bool _hasGeneratedMessageSuperclass(
+    ir.Class protobufGeneratedMessageClass,
+    ir.Class enclosingClass,
+  ) {
+    ir.Class? current = enclosingClass;
+    while (current != null) {
+      if (current == protobufGeneratedMessageClass) return true;
+
+      current = current.superclass;
+    }
+    return false;
+  }
+
   static ProtobufImpactHandler? createIfApplicable(
     KernelToElementMap elementMap,
     ir.Member node,
   ) {
     if (!elementMap.options.enableProtoShaking) return null;
 
+    if (node.name.text != metadataFieldName) return null;
+
     // Not all programs will include the protobuf library. Ideally those
     // programs wouldn't enable proto shaking but we can be conservative and not
     // assume the library exists.
     final protobufGeneratedMessageClass = elementMap.env.libraryIndex
         .tryGetClass(protobufLibraryUri, 'GeneratedMessage');
 
-    // Only applicable if the member is in a subclass of GeneratedMessage and
-    // the name matches the static metadata field.
-    if (protobufGeneratedMessageClass != null &&
-        node.enclosingClass?.superclass == protobufGeneratedMessageClass &&
-        node.name.text == metadataFieldName) {
-      return ProtobufImpactHandler._(elementMap, node.enclosingClass!);
+    if (protobufGeneratedMessageClass == null) return null;
+
+    final enclosingClass = node.enclosingClass;
+    if (enclosingClass == null) return null;
+
+    // Applicable if the member is in a subclass of GeneratedMessage.
+    if (enclosingClass.superclass == protobufGeneratedMessageClass) {
+      return ProtobufImpactHandler._(elementMap, enclosingClass);
+    }
+
+    // Applicable if the member is in a subclass of GeneratedMessage with mixins
+    // included.
+    if (elementMap.options.enableProtoMixinShaking) {
+      final superclass = enclosingClass.superclass;
+      if (superclass != null &&
+          superclass.isMixinApplication &&
+          _hasGeneratedMessageSuperclass(
+            protobufGeneratedMessageClass,
+            superclass,
+          )) {
+        return ProtobufImpactHandler._(elementMap, enclosingClass);
+      }
     }
     return null;
   }

pkg/compiler/lib/src/options.dart

@@ -705,6 +705,7 @@ class CompilerOptions implements DiagnosticOptions {
   bool disableDiagnosticByteCache = false;
 
   bool enableProtoShaking = false;
+  bool enableProtoMixinShaking = false;
 
   bool get producesModifiedDill =>
       stage == CompilerStage.closedWorld && enableProtoShaking;
@@ -959,6 +960,10 @@ class CompilerOptions implements DiagnosticOptions {
         Flags.laxRuntimeTypeToString,
       )
       ..enableProtoShaking = _hasOption(options, Flags.enableProtoShaking)
+      ..enableProtoMixinShaking = _hasOption(
+        options,
+        Flags.enableProtoMixinShaking,
+      )
       ..testMode = _hasOption(options, Flags.testMode)
       ..trustPrimitives = _hasOption(options, Flags.trustPrimitives)
       ..useFrequencyNamer =
@@ -1172,6 +1177,10 @@ class CompilerOptions implements DiagnosticOptions {
       mergeFragmentsThreshold = _mergeFragmentsThreshold;
     }
 
+    if (enableProtoMixinShaking) {
+      enableProtoShaking = true;
+    }
+
     environment['dart.web.assertions_enabled'] = '$enableUserAssertions';
     environment['dart.tool.dart2js'] = '${true}';
     environment['dart.tool.dart2js.minify'] = '$enableMinification';