[dyn_modules] Fix overriding of a method declared in a mixin

Mixin transformation copies members of a mixin into a mixin
application class. Copied members should still behave similarly to
original members in terms of overriding.

When validating a dynamic module, overriding a copy of mixin
member should be allowed if original member can be overridden.

When annotating AST with dynamic interface pragmas, can-be-overridden
pragmas should apply to all copies of mixin members.

TEST=pkg/dynamic_modules/test/data/override_mixin_method
Fixes b/418681054

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

Author: alexmarkov

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

@@ -0,0 +1,11 @@
+# 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.
+extendable:
+  - library: 'shared/shared.dart'
+
+callable:
+  - library: 'shared/shared.dart'
+
+can-be-overridden:
+  - library: 'shared/shared.dart'

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

@@ -0,0 +1,20 @@
+// 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';
+
+import 'shared/shared.dart';
+
+/// A dynamic module can override a method declared in a mixin.
+void main() async {
+  final objs = (await helper.load('entry1.dart')) as List<A>;
+  final o1 = objs[0];
+  Expect.equals('DynA1.foo, super: M2.foo', o1.foo());
+  Expect.equals('M2.bar', o1.bar());
+  final o2 = objs[1];
+  Expect.equals('M2.foo', o2.foo());
+  Expect.equals('M3.bar', o2.bar());
+  helper.done();
+}

pkg/dynamic_modules/test/data/override_mixin_method/modules/entry1.dart

@@ -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.
+
+import '../shared/shared.dart';
+
+class DynA1 extends A {
+  @override
+  String foo() => 'DynA1.foo, super: ${super.foo()}';
+}
+
+class DynA2 extends A with M3 {}
+
+@pragma('dyn-module:entry-point')
+List<A> dynamicModuleEntrypoint() {
+  return <A>[DynA1(), DynA2()];
+}

pkg/dynamic_modules/test/data/override_mixin_method/shared/shared.dart

@@ -0,0 +1,23 @@
+// 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.
+
+class A extends B with M1, M2 {}
+
+class B {
+  String bar() => 'B.bar';
+}
+
+mixin M1 on B {}
+
+mixin M2 on B, M1 {
+  String foo() => 'M2.foo';
+
+  @override
+  String bar() => 'M2.bar';
+}
+
+mixin M3 on B {
+  @override
+  String bar() => 'M3.bar';
+}

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

@@ -616,6 +616,9 @@ class _DynamicModuleValidator extends RecursiveVisitor {
     if (target is Procedure) {
       target = _unwrapMixinStubs(target);
     }
+    if (target is Member) {
+      target = _unwrapMixinCopy(target);
+    }
     if (!_isFromDynamicModule(target) &&
         !_isSpecified(target, spec.callable) &&
         !languageImplPragmas.isCallable(target)) {
@@ -692,6 +695,22 @@ class _DynamicModuleValidator extends RecursiveVisitor {
     return member;
   }
 
+  // Unwrap copied method from an eliminated mixin to get actual
+  // interface member.
+  Member _unwrapMixinCopy(Member member) {
+    if (!member.isInstanceMember) {
+      return member;
+    }
+    Class enclosingClass = member.enclosingClass!;
+    if (!enclosingClass.isEliminatedMixin) {
+      return member;
+    }
+    // Coverage-ignore-block(suite): Not run.
+    Class origin = enclosingClass.implementedTypes.last.classNode;
+    return hierarchy.getInterfaceMember(origin, member.name,
+        setter: member is Procedure && member.isSetter)!;
+  }
+
   void _verifyOverrides(
       List<Member> implementationMembers, List<Member> interfaceMembers) {
     int i = 0, j = 0;
@@ -716,6 +735,7 @@ class _DynamicModuleValidator extends RecursiveVisitor {
   }
 
   void _verifyOverride(Member ownMember, Member superMember) {
+    superMember = _unwrapMixinCopy(superMember);
     if (!_isFromDynamicModule(superMember) &&
         !_isSpecified(superMember, spec.canBeOverridden) &&
         !languageImplPragmas.canBeOverridden(superMember)) {

pkg/front_end/test/coverage_suite_expected.dart

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

pkg/vm/lib/transformations/dynamic_interface_annotator.dart

@@ -66,6 +66,14 @@ void annotateComponent(
   );
 
   final hierarchy = ClassHierarchy(component, coreTypes);
+
+  copyCanBeOverriddenToMixinApplications(
+    canBeOverriddenAnnotator.annotatedMembers,
+    canBeOverriddenAnnotator.pragma,
+    component,
+    hierarchy,
+  );
+
   _ImplicitOverridesAnnotator(
     pragmaConstant(coreTypes, kDynModuleCanBeOverriddenImplicitlyPragmaName),
     hierarchy,
@@ -630,3 +638,49 @@ class _DiscoverLanguageImplPragmasVisitor extends RecursiveVisitor {
     }
   }
 }
+
+// Mixin transformation copies all members of mixins into mixin applications.
+// So we need to copy can-be-overridden pragmas from members of mixins to
+// their copies in the transformed mixin applications.
+void copyCanBeOverriddenToMixinApplications(
+  Set<Member> overriddenMembers,
+  Constant pragma,
+  Component component,
+  ClassHierarchy hierarchy,
+) {
+  void processMember(Member original, Class mixinApplication) {
+    if (!original.isInstanceMember) {
+      return;
+    }
+    if (!overriddenMembers.contains(original)) {
+      return;
+    }
+    final member = ClassHierarchy.findMemberByName(
+      hierarchy.getDeclaredMembers(
+        mixinApplication,
+        setters: original is Procedure && original.isSetter,
+      ),
+      original.name,
+    );
+    if (member == null) {
+      return;
+    }
+    if (overriddenMembers.add(member)) {
+      member.addAnnotation(ConstantExpression(pragma));
+    }
+  }
+
+  for (final library in component.libraries) {
+    for (final cls in library.classes) {
+      if (cls.isEliminatedMixin) {
+        final origin = cls.implementedTypes.last.classNode;
+        for (final proc in origin.procedures) {
+          processMember(proc, cls);
+        }
+        for (final field in origin.fields) {
+          processMember(field, cls);
+        }
+      }
+    }
+  }
+}