[dart2wasm] Optimize fine grained partitioning for deferred loading

This saves around 730 KB (-7.7%) on essentials main module.

The existing fine grained partitioning of code into wasm modules
operates on static elements. That means as soon as a constructor is
called, all instance methods of a class are included as well.

This CL improves upon this using the insight that some instance methods
are always accessed via direct calls (i.e. all call sites to the
instance member are devirtualized).

For those methods that are never called indirectly, the partitioning
algorithm can avoid enquing those instance methods when the class is
enqueued and instead enqueue them when the devirtualized call site is
hit.

An example where this can happen is e.g. main module allocates a proto
class but doesn't access field X. Currently when hitting the constructor
we'll enqueue all instance members. Now we don't enqueue X (as all uses
of X are direct calls to the X getter). That means if X is only used in
a deferred module, then we can move the X getter to that deferred
module.

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

Author: mkustermann

pkg/dart2wasm/lib/deferred_load/dependencies.dart

@@ -2,22 +2,27 @@
 // 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 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/kernel.dart';
 import 'package:kernel/library_index.dart';
 
 import '../modules.dart';
+import 'devirtualization_oracle.dart';
 
 class DependenciesCollector {
   final CoreTypes _coreTypes;
+  final ClosedWorldClassHierarchy _classHierarchy;
+  final DevirtualizionOracle _devirtualizionOracle;
   final DeferredModuleLoadingMap _loadingMap;
 
   late final _checkLibraryIsLoadedFromLoadId = _coreTypes.index.getProcedure(
       'dart:_internal',
       LibraryIndex.topLevel,
       'checkLibraryIsLoadedFromLoadId');
 
-  DependenciesCollector(this._coreTypes, this._loadingMap);
+  DependenciesCollector(this._coreTypes, this._classHierarchy,
+      this._devirtualizionOracle, this._loadingMap);
 
   /// Returns the set of constants referred to by the (possibly composed)
   /// [constant].
@@ -38,7 +43,11 @@ class DependenciesCollector {
     }
 
     final collector = _ReferenceDependenciesCollector._(
-        _recognizeDeferredLoadingGuard, reference, deps);
+        _recognizeDeferredLoadingGuard,
+        _classHierarchy,
+        _devirtualizionOracle,
+        reference,
+        deps);
     if (node is Procedure) {
       node.accept(collector);
       return deps;
@@ -90,19 +99,31 @@ class DependenciesCollector {
     return null;
   }
 
-  static void _enqueueInstanceMembers(
-      Class klass, DirectReferenceDependencies deps) {
+  void _enqueueInstanceMembers(Class klass, DirectReferenceDependencies deps) {
     final superReference = klass.superclass?.reference;
     if (superReference != null) {
       deps.references.add(superReference);
     }
     for (final m in klass.members) {
       if (m.isInstanceMember) {
         if (m is Field) {
-          deps.references.add(m.fieldReference);
+          if (!_devirtualizionOracle
+              .isAlwaysStaticallyDispatchedTo(m.getterReference)) {
+            deps.references.add(m.getterReference);
+          }
+          if (m.hasSetter) {
+            if (!_devirtualizionOracle
+                .isAlwaysStaticallyDispatchedTo(m.setterReference!)) {
+              deps.references.add(m.setterReference!);
+            }
+          }
           continue;
         }
-        deps.references.add(m.reference);
+        assert(m is Procedure);
+        if (!_devirtualizionOracle
+            .isAlwaysStaticallyDispatchedTo(m.reference)) {
+          deps.references.add(m.reference);
+        }
       }
     }
   }
@@ -120,13 +141,19 @@ class _ConstantDependenciesCollector extends RecursiveVisitor {
 
 class _ReferenceDependenciesCollector extends RecursiveVisitor {
   final LibraryDependency? Function(Let node) recognizeDeferredLoadingGuard;
+  final DevirtualizionOracle _devirtualizionOracle;
+  final ClosedWorldClassHierarchy _classHierarchy;
 
   final Reference reference;
   final DirectReferenceDependencies deps;
   final List<LibraryDependency> _activeLoadGuards = [];
 
   _ReferenceDependenciesCollector._(
-      this.recognizeDeferredLoadingGuard, this.reference, this.deps);
+      this.recognizeDeferredLoadingGuard,
+      this._classHierarchy,
+      this._devirtualizionOracle,
+      this.reference,
+      this.deps);
 
   @override
   void visitLet(Let node) {
@@ -143,6 +170,42 @@ class _ReferenceDependenciesCollector extends RecursiveVisitor {
     }
   }
 
+  @override
+  void visitSuperPropertyGet(SuperPropertyGet node) {
+    _addSuperTargetReference(node.interfaceTarget, setter: false);
+  }
+
+  @override
+  void visitSuperPropertySet(SuperPropertySet node) {
+    _addSuperTargetReference(node.interfaceTarget, setter: true);
+  }
+
+  @override
+  void visitSuperMethodInvocation(SuperMethodInvocation node) {
+    _addSuperTargetReference(node.interfaceTarget, setter: false);
+  }
+
+  @override
+  void visitInstanceGet(InstanceGet node) {
+    super.visitInstanceGet(node);
+    final target = _devirtualizionOracle.staticDispatchTargetForGet(node);
+    if (target != null) addReference(target);
+  }
+
+  @override
+  void visitInstanceSet(InstanceSet node) {
+    super.visitInstanceSet(node);
+    final target = _devirtualizionOracle.staticDispatchTargetForSet(node);
+    if (target != null) addReference(target);
+  }
+
+  @override
+  void visitInstanceInvocation(InstanceInvocation node) {
+    super.visitInstanceInvocation(node);
+    final target = _devirtualizionOracle.staticDispatchTargetForCall(node);
+    if (target != null) addReference(target);
+  }
+
   @override
   void visitStaticGet(StaticGet node) {
     super.visitStaticGet(node);
@@ -256,6 +319,19 @@ class _ReferenceDependenciesCollector extends RecursiveVisitor {
       deps.deferredConstants[used] = {_activeLoadGuards.last};
     }
   }
+
+  void _addSuperTargetReference(Member interfaceTarget,
+      {required bool setter}) {
+    final member = _classHierarchy.getDispatchTarget(
+        (reference.asMember).enclosingClass!.superclass!, interfaceTarget.name,
+        setter: setter)!;
+    if (setter) {
+      addReference(
+          member is Field ? member.setterReference! : member.reference);
+    } else {
+      addReference(member is Field ? member.getterReference : member.reference);
+    }
+  }
 }
 
 class DirectReferenceDependencies {

pkg/dart2wasm/lib/deferred_load/devirtualization_oracle.dart

@@ -0,0 +1,99 @@
+// Copyright (c) 2025, 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.
+
+import 'package:kernel/kernel.dart';
+import 'package:vm/metadata/direct_call.dart';
+import 'package:vm/metadata/procedure_attributes.dart';
+import 'package:vm/metadata/table_selector.dart';
+
+/// Oracle that knows whether instance members will be always called directly
+/// (i.e. all call sites are devirtualized direct calls instead of instance
+/// calls).
+class DevirtualizionOracle {
+  final Component component;
+
+  late final Map<TreeNode, DirectCallMetadata> _directCallMetadata =
+      (component.metadata[DirectCallMetadataRepository.repositoryTag]
+              as DirectCallMetadataRepository)
+          .mapping;
+
+  late final Map<TreeNode, ProcedureAttributesMetadata>
+      _procedureAttributeMetadata =
+      (component.metadata[ProcedureAttributesMetadataRepository.repositoryTag]
+              as ProcedureAttributesMetadataRepository)
+          .mapping;
+  late final List<TableSelectorInfo> _selectorMetadata =
+      (component.metadata[TableSelectorMetadataRepository.repositoryTag]
+              as TableSelectorMetadataRepository)
+          .mapping[component]!
+          .selectors;
+
+  DevirtualizionOracle(this.component);
+
+  /// Whether all call sites are guaranteed to be devirtualized.
+  bool isAlwaysStaticallyDispatchedTo(Reference reference) {
+    final member = reference.asMember;
+    assert(member.isInstanceMember);
+    final metadata = _procedureAttributeMetadata[member]!;
+
+    final bool isGetter =
+        member is Field && reference == member.getterReference ||
+            member is Procedure && member.isGetter;
+
+    if (isGetter) {
+      if (metadata.getterCalledDynamically) return false;
+
+      final getterId = metadata.getterSelectorId;
+      if (getterId != ProcedureAttributesMetadata.kInvalidSelectorId) {
+        final selector = _selectorMetadata[getterId];
+        if (selector.callCount != 0 || selector.tornOff) {
+          return false;
+        }
+      }
+    } else {
+      if (metadata.methodOrSetterCalledDynamically) return false;
+      // This method may be dynamically torn off.
+      if (metadata.getterCalledDynamically) return false;
+
+      final methodOrSetterId = metadata.methodOrSetterSelectorId;
+      if (methodOrSetterId != ProcedureAttributesMetadata.kInvalidSelectorId) {
+        final selector = _selectorMetadata[methodOrSetterId];
+        if (selector.callCount != 0 || selector.tornOff) {
+          return false;
+        }
+      }
+    }
+
+    // All uses of this [member] will be devirtualized uses. The deferred
+    // loading partitioning algorithm will - on all call sites (which are
+    // guaranteed to be devirtualized) - make this target a direct dependency
+    // (via calling `staticDispatchTargetFor*` methods below) instead of
+    // conservatively enquing this method whenever the class is allocated.
+    return true;
+  }
+
+  Reference? staticDispatchTargetForGet(InstanceGet node) {
+    final devirtualizedTarget = _directCallMetadata[node]?.targetMember;
+    if (devirtualizedTarget == null) return null;
+    if (devirtualizedTarget is Field) {
+      return devirtualizedTarget.getterReference;
+    }
+    return (devirtualizedTarget as Procedure).reference;
+  }
+
+  Reference? staticDispatchTargetForSet(InstanceSet node) {
+    final devirtualizedTarget = _directCallMetadata[node]?.targetMember;
+    if (devirtualizedTarget == null) return null;
+    if (devirtualizedTarget is Field) {
+      return devirtualizedTarget.setterReference;
+    }
+    return (devirtualizedTarget as Procedure).reference;
+  }
+
+  Reference? staticDispatchTargetForCall(InstanceInvocation node) {
+    final devirtualizedTarget = _directCallMetadata[node]?.targetMember;
+    if (devirtualizedTarget == null) return null;
+    return (devirtualizedTarget as Procedure).reference;
+  }
+}

pkg/dart2wasm/lib/deferred_load/partition.dart

@@ -4,11 +4,13 @@
 
 import 'dart:collection';
 
+import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/kernel.dart';
 
 import '../modules.dart' show DeferredModuleLoadingMap;
 import 'dependencies.dart';
+import 'devirtualization_oracle.dart';
 import 'import_set.dart';
 
 export 'import_set.dart' show Part;
@@ -23,7 +25,11 @@ Partitioning partitionAppplication(CoreTypes coreTypes, Component component,
       }
     }
   }
-  final depsCollector = DependenciesCollector(coreTypes, loadingMap);
+  final classHierarchy =
+      ClassHierarchy(component, coreTypes) as ClosedWorldClassHierarchy;
+  final devirtualizionOracle = DevirtualizionOracle(component);
+  final depsCollector = DependenciesCollector(
+      coreTypes, classHierarchy, devirtualizionOracle, loadingMap);
   final algorithm = _Algorithm(component, depsCollector, allDeferredImports);
   return algorithm.run(roots);
 }