[dart2wasm] Fix access of constants under deferred load guard

When accessing a constant under a load guard we can push the constant to
the deferred module (as we only access it under the guard that the
module has been loaded). The access has to therefore also use the
constant initializer function from the deferred module.

We also remove `--extra-compiler-option` prefix for
`--enable-deferred-loading` as the prefix isn't recognized by
dartdev.

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

Author: mkustermann

pkg/dart2wasm/lib/constants.dart

@@ -1557,7 +1557,7 @@ class _ConstantAccessor {
 
     if (existingDefinition != null) {
       // We already have a defined constant. Possibly import it and then use it.
-      return _readDefinedConstant(b, info, existingDefinition);
+      return _readDefinedConstant(b, b.moduleBuilder, info, existingDefinition);
     }
 
     // We have to guarantee that using the constant synchronously works. If the
@@ -1573,7 +1573,7 @@ class _ConstantAccessor {
         usingModule == translator.mainModule) {
       final definition =
           _defineConstantInModuleRecursive(translator.mainModule, info);
-      return _readDefinedConstant(b, info, definition);
+      return _readDefinedConstant(b, usingModule, info, definition);
     }
 
     // Remember for the transitive DAG of [constant] that we use it in this
@@ -1602,18 +1602,30 @@ class _ConstantAccessor {
     if (patchInstructions != null) {
       translator.linkingActions.add(() {
         // All constant uses have been discovered during codegen phase so we can
-        // know decide into which module to place the constant and patch the
+        // now decide into which module to place the constant and patch the
         // constant access to load it from there.
         final definition =
             info._definition ?? _defineConstantInModuleRecursive(null, info);
-        _readDefinedConstant(patchInstructions, info, definition);
+        _readDefinedConstant(patchInstructions, usingModule, info, definition);
       });
     }
 
     return info.type;
   }
 
-  w.ValueType _readDefinedConstant(w.InstructionsBuilder b, ConstantInfo info,
+  /// Reads the given constant.
+  ///
+  /// Normally `b.moduleBuilder == usingModule`, except for the situation where
+  /// the read happens under a load guard.
+  ///
+  /// In that case the `b.moduleBuilder` may not have an initializer function
+  /// (to reduce its size) and instead it can rely on the load guarded deferred
+  /// module to be loaded by the time we read the constant, so it can use that
+  /// deferred module's constant initializer.
+  w.ValueType _readDefinedConstant(
+      w.InstructionsBuilder b,
+      w.ModuleBuilder usingModule,
+      ConstantInfo info,
       ConstantDefinition definition) {
     // Eagerly initialized constant.
     if (definition is GlobalBasedConstantDefinition && !definition.isLazy) {
@@ -1630,7 +1642,7 @@ class _ConstantAccessor {
         w.Label done = b.block(const [], [info.type]);
         translator.globals.readGlobal(b, definition.global);
         b.br_on_non_null(done);
-        translator.callFunction(definition.initializer(b.moduleBuilder), b);
+        translator.callFunction(definition.initializer(usingModule), b);
         b.end();
         break;
       case TableBasedConstantDefinition():
@@ -1639,7 +1651,7 @@ class _ConstantAccessor {
         b.i32_const(definition.tableIndex);
         b.table_get(tableImporter.get(definition.table, b.moduleBuilder));
         b.br_on_non_null(done);
-        translator.callFunction(definition.initializer(b.moduleBuilder), b);
+        translator.callFunction(definition.initializer(usingModule), b);
         b.end();
         break;
     }

pkg/dart2wasm/tool/compile_benchmark

@@ -146,7 +146,7 @@ while [ $# -gt 0 ]; do
       shift
       ;;
 
-    --extra-compiler-option=--enable-deferred-loading)
+    --enable-deferred-loading | --extra-compiler-option=--enable-deferred-loading)
       MULTI_MODULE=1
       DART2WASM_ARGS+=("--enable-deferred-loading")
       shift

tests/language/deferred/regression_22995_test.dart

@@ -4,7 +4,7 @@
 
 // Test that closurizing a function implies a dependency on its type.
 
-// dart2wasmOptions=--extra-compiler-option=--enable-deferred-loading -O0
+// dart2wasmOptions=--enable-deferred-loading -O0
 
 import "package:expect/expect.dart";
 

tests/web/wasm/deferred_constant_use_under_load_guard_def.dart

@@ -0,0 +1,29 @@
+// 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 'deferred_constant_use_under_load_guard_def1.dart' deferred as D1;
+import 'deferred_constant_use_under_load_guard_def2.dart' deferred as D2;
+
+Future runTest() async {
+  await D1.loadLibrary();
+  await D2.loadLibrary();
+
+  // Access of `foo` under load guard D1.
+  D1.printValue(foo);
+
+  // Access of `foo` under load guard D2.
+  D2.printValue(foo);
+
+  // To prevent signature shaking from removing parameter and pushing `foo` to
+  // callee.
+  D1.printValue('a');
+  D2.printValue('b');
+}
+
+class FooConst {
+  final String value;
+  const FooConst(this.value);
+}
+
+const foo = FooConst('foo');

tests/web/wasm/deferred_constant_use_under_load_guard_def1.dart

@@ -0,0 +1,7 @@
+// 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.
+
+void printValue(value) {
+  print(value);
+}

tests/web/wasm/deferred_constant_use_under_load_guard_def2.dart

@@ -0,0 +1,7 @@
+// 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.
+
+void printValue(value) {
+  print(value);
+}

tests/web/wasm/deferred_constant_use_under_load_guard_test.dart

@@ -0,0 +1,12 @@
+// 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.
+//
+// dart2wasmOptions=--enable-deferred-loading
+
+import 'deferred_constant_use_under_load_guard_def.dart' deferred as D;
+
+main() async {
+  await D.loadLibrary();
+  await D.runTest();
+}

tests/web/wasm/source_map_simple_optimized_deferred_test.dart

@@ -2,7 +2,7 @@
 // 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.
 
-// dart2wasmOptions=-O4 --no-strip-wasm --extra-compiler-option=--enable-deferred-loading --extra-compiler-option=-DTEST_COMPILATION_DIR=$TEST_COMPILATION_DIR
+// dart2wasmOptions=-O4 --no-strip-wasm --enable-deferred-loading --extra-compiler-option=-DTEST_COMPILATION_DIR=$TEST_COMPILATION_DIR
 
 import 'source_map_simple_lib.dart' as Lib;