[dynamic modules] Respect dyn-module:language-impl:* pragmas during dynamic module validation

Dynamic module validation now accepts reference to classes and members
from 'dart:*' libraries if they are annotated with
dyn-module:language-impl:* pragmas. This matches the behavior of
dynamic interface annotator.

This is a follow-up to
https://dart-review.googlesource.com/c/sdk/+/418663.

Also, when checking for possible dynamic overrides in TFA,
treat _enumToString from dart:core as a public name because
front-end desugars enums into classes which override
private _enumToString method in a different library.

TEST=pkg/dynamic_modules/test/data/enum
Fixes b/395992622

Change-Id: I45ed9855f806224a510fa4e56962607de3371eb0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/423820
Reviewed-by: Slava Egorov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Nate Biggs <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

pkg/dart2wasm/lib/compile.dart

@@ -223,7 +223,6 @@ Future<CompilationResult> compileToModule(
     moduleStrategy = DynamicMainModuleStrategy(
         component,
         coreTypes,
-        target,
         File.fromUri(dynamicInterfaceUri).readAsStringSync(),
         options.dynamicInterfaceUri!);
   } else if (isDynamicModule) {

pkg/dart2wasm/lib/dynamic_modules.dart

@@ -5,7 +5,6 @@
 import 'package:kernel/ast.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/library_index.dart';
-import 'package:kernel/target/targets.dart' show Target;
 import 'package:vm/metadata/procedure_attributes.dart'
     show ProcedureAttributesMetadata;
 import 'package:vm/transformations/dynamic_interface_annotator.dart'
@@ -102,7 +101,6 @@ class DynamicModuleOutputData extends ModuleOutputData {
 class DynamicMainModuleStrategy extends DefaultModuleStrategy with KernelNodes {
   @override
   final CoreTypes coreTypes;
-  final Target target;
   @override
   final LibraryIndex index;
   final Uri dynamicInterfaceSpecificationBaseUri;
@@ -111,7 +109,6 @@ class DynamicMainModuleStrategy extends DefaultModuleStrategy with KernelNodes {
   DynamicMainModuleStrategy(
       super.component,
       this.coreTypes,
-      this.target,
       this.dynamicInterfaceSpecification,
       this.dynamicInterfaceSpecificationBaseUri)
       : index = coreTypes.index;
@@ -120,7 +117,7 @@ class DynamicMainModuleStrategy extends DefaultModuleStrategy with KernelNodes {
   void prepareComponent() {
     // Annotate the kernel with info from dynamic interface.
     dynamic_interface_annotator.annotateComponent(dynamicInterfaceSpecification,
-        dynamicInterfaceSpecificationBaseUri, component, coreTypes, target);
+        dynamicInterfaceSpecificationBaseUri, component, coreTypes);
     _addImplicitPragmas();
     _addMetadataPragmas();
   }

pkg/dynamic_modules/test/data/enum/dynamic_interface.yaml

@@ -0,0 +1,17 @@
+# 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.
+
+callable:
+  # TODO(sigmund): This should be included by default
+  - library: 'dart:core'
+    class: 'Object'
+  - library: 'dart:core'
+    class: 'String'
+  - library: 'dart:core'
+    class: 'int'
+  - library: 'dart:core'
+    class: 'List'
+  - library: 'dart:core'
+    class: 'pragma'
+    member: '_'

pkg/dynamic_modules/test/data/enum/main.dart

@@ -0,0 +1,13 @@
+// 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 '../../common/testing.dart' as helper;
+import 'package:expect/expect.dart';
+
+void main() async {
+  final result = await helper.load('entry1.dart') as Enum;
+  Expect.equals('e2', result.name);
+  Expect.equals('Foo.e2', result.toString());
+  helper.done();
+}

pkg/dynamic_modules/test/data/enum/modules/entry1.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.
+
+enum Foo {
+  e1,
+  e2,
+  e3;
+}
+
+@pragma('dyn-module:entry-point')
+Object? dynamicModuleEntrypoint() => Foo.e2;

pkg/front_end/lib/src/api_prototype/dynamic_module_validator.dart

@@ -5,4 +5,4 @@
 library front_end.dynamic_module_validator;
 
 export '../kernel/dynamic_module_validator.dart'
-    show DynamicInterfaceSpecification;
+    show DynamicInterfaceLanguageImplPragmas, DynamicInterfaceSpecification;

pkg/front_end/lib/src/kernel/dynamic_module_validator.dart

@@ -4,6 +4,7 @@
 
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
+import 'package:kernel/core_types.dart' show CoreTypes;
 import 'package:kernel/library_index.dart' show LibraryIndex;
 import 'package:yaml/yaml.dart';
 import '../source/source_loader.dart' show SourceLoader;
@@ -28,15 +29,18 @@ void validateDynamicModule(
     String dynamicInterfaceSpecification,
     Uri dynamicInterfaceSpecificationUri,
     Component component,
+    CoreTypes coreTypes,
     ClassHierarchy hierarchy,
     List<Library> libraries,
     SourceLoader loader) {
   final DynamicInterfaceSpecification spec = new DynamicInterfaceSpecification(
       dynamicInterfaceSpecification,
       dynamicInterfaceSpecificationUri,
       component);
+  final DynamicInterfaceLanguageImplPragmas languageImplPragmas =
+      new DynamicInterfaceLanguageImplPragmas(coreTypes);
   final _DynamicModuleValidator validator = new _DynamicModuleValidator(
-      spec, new Set.of(libraries), hierarchy, loader);
+      spec, languageImplPragmas, new Set.of(libraries), hierarchy, loader);
   for (Library library in libraries) {
     library.accept(validator);
   }
@@ -183,17 +187,73 @@ class DynamicInterfaceSpecification {
   }
 }
 
+/// Recognizes dyn-module:language-impl:* pragmas which can be used
+/// to annotate classes and members in core libraries to include
+/// them to the dynamic interface automatically.
+class DynamicInterfaceLanguageImplPragmas {
+  static const String extendablePragmaName =
+      "dyn-module:language-impl:extendable";
+  static const String canBeOverriddenPragmaName =
+      "dyn-module:language-impl:can-be-overridden";
+  static const String callablePragmaName = "dyn-module:language-impl:callable";
+
+  final CoreTypes coreTypes;
+  DynamicInterfaceLanguageImplPragmas(this.coreTypes);
+
+  bool isPlatformLibrary(Library library) => library.importUri.isScheme('dart');
+
+  bool isExtendable(Class node) =>
+      isPlatformLibrary(node.enclosingLibrary) &&
+      // Coverage-ignore(suite): Not run.
+      isAnnotatedWith(node, extendablePragmaName);
+
+  bool canBeOverridden(Member node) =>
+      isPlatformLibrary(node.enclosingLibrary) &&
+      // Coverage-ignore(suite): Not run.
+      isAnnotatedWith(node, canBeOverriddenPragmaName);
+
+  bool isCallable(TreeNode node) => switch (node) {
+        Member() => isPlatformLibrary(node.enclosingLibrary) &&
+            // Coverage-ignore(suite): Not run.
+            (isAnnotatedWith(node, callablePragmaName) ||
+                (!node.name.isPrivate &&
+                    node.enclosingClass != null &&
+                    isAnnotatedWith(node.enclosingClass!, callablePragmaName))),
+        Class() => isPlatformLibrary(node.enclosingLibrary) &&
+            isAnnotatedWith(node, callablePragmaName),
+        _ => // Coverage-ignore(suite): Not run.
+          throw 'Unexpected node ${node.runtimeType} $node'
+      };
+
+  bool isAnnotatedWith(Annotatable node, String pragmaName) {
+    for (Expression annotation in node.annotations) {
+      if (annotation case ConstantExpression(:var constant)) {
+        if (constant case InstanceConstant(:var classNode, :var fieldValues)
+            when classNode == coreTypes.pragmaClass) {
+          // Coverage-ignore-block(suite): Not run.
+          if (fieldValues[coreTypes.pragmaName.fieldReference]
+              case StringConstant(:var value) when value == pragmaName) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+}
+
 class _DynamicModuleValidator extends RecursiveVisitor {
   final DynamicInterfaceSpecification spec;
+  final DynamicInterfaceLanguageImplPragmas languageImplPragmas;
   final Set<Library> moduleLibraries;
   final ClassHierarchy hierarchy;
   final SourceLoader loader;
   final Set<Constant> _visitedConstants = new Set<Constant>.identity();
 
   TreeNode? _enclosingTreeNode;
 
-  _DynamicModuleValidator(
-      this.spec, this.moduleLibraries, this.hierarchy, this.loader) {
+  _DynamicModuleValidator(this.spec, this.languageImplPragmas,
+      this.moduleLibraries, this.hierarchy, this.loader) {
     _addLibraryExports(spec.callable);
     _addLibraryExports(spec.extendable);
     _addLibraryExports(spec.canBeOverridden);
@@ -493,7 +553,9 @@ class _DynamicModuleValidator extends RecursiveVisitor {
     if (target is Procedure) {
       target = _unwrapMixinStubs(target);
     }
-    if (!_isFromDynamicModule(target) && !_isSpecified(target, spec.callable)) {
+    if (!_isFromDynamicModule(target) &&
+        !_isSpecified(target, spec.callable) &&
+        !languageImplPragmas.isCallable(target)) {
       switch (target) {
         case Constructor():
           String name = target.enclosingClass.name;
@@ -534,7 +596,8 @@ class _DynamicModuleValidator extends RecursiveVisitor {
   void _verifyExtendable(Supertype base, Class node) {
     final Class baseClass = base.classNode;
     if (!_isFromDynamicModule(baseClass) &&
-        !_isSpecified(baseClass, spec.extendable)) {
+        !_isSpecified(baseClass, spec.extendable) &&
+        !languageImplPragmas.isExtendable(baseClass)) {
       loader.addProblem(
           templateClassShouldBeListedAsExtendableInDynamicInterface
               .withArguments(baseClass.name),
@@ -578,7 +641,8 @@ class _DynamicModuleValidator extends RecursiveVisitor {
 
   void _verifyOverride(Member ownMember, Member superMember) {
     if (!_isFromDynamicModule(superMember) &&
-        !_isSpecified(superMember, spec.canBeOverridden)) {
+        !_isSpecified(superMember, spec.canBeOverridden) &&
+        !languageImplPragmas.canBeOverridden(superMember)) {
       loader.addProblem(
           templateMemberShouldBeListedAsCanBeOverriddenInDynamicInterface
               .withArguments(

pkg/front_end/lib/src/kernel/kernel_target.dart

@@ -1484,6 +1484,7 @@ class KernelTarget {
             dynamicInterfaceSpecification,
             dynamicInterfaceSpecificationUri,
             component!,
+            loader.coreTypes,
             loader.hierarchy,
             loader.libraries,
             loader);

pkg/front_end/test/coverage_suite_expected.dart

@@ -710,7 +710,7 @@ const Map<String, ({int hitCount, int missCount})> _expect = {
   ),
   // 100.0%.
   "package:front_end/src/kernel/dynamic_module_validator.dart": (
-    hitCount: 322,
+    hitCount: 358,
     missCount: 0,
   ),
   // 100.0%.

pkg/front_end/test/spell_checking_list_code.txt

@@ -1322,6 +1322,7 @@ postfix
 pound
 pow
 pragma
+pragmas
 pre
 prebuild
 prebuilt