[cfe] Merge clone with existing procedure in mixin transformation

This ensure that any existing references to the original procedure
will correctly refer to the cloned procedure after transformation.

Change-Id: I08f561f11e88d717041009e6a9bd9bb6e8054d88
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/137976
Reviewed-by: Jens Johansen <jensj@google.com>
Commit-Queue: Johnni Winther <johnniwinther@google.com>

Author: johnniwinther

pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart

@@ -2784,11 +2784,7 @@ class InterfaceConflict extends DelayedMember {
         }
         debug?.log("Combined Member Signature of ${fullNameForErrors}: "
             "added stub $stub");
-        if (classBuilder.isMixinApplication) {
-          return combinedMemberSignatureResult = bestMemberSoFar;
-        } else {
-          return combinedMemberSignatureResult = stub;
-        }
+        return combinedMemberSignatureResult = stub;
       }
     }
 

pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.strong.expect

@@ -28,7 +28,7 @@ class C = self::B with self::M implements self::I<core::int*> {
     return super.{self::B::f}(x);
 }
 static method g1(self::C* c) → void {
-  c.{self::M::f}(1);
+  c.{self::C::f}(1);
 }
 static method g2(self::I<core::num*>* i) → void {
   i.{self::I::f}(1.5);

pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_mixin.dart.strong.transformed.expect

@@ -27,7 +27,7 @@ class C extends self::B implements self::I<core::int*>, self::M /*isEliminatedMi
   method f(generic-covariant-impl core::int* x) → void {}
 }
 static method g1(self::C* c) → void {
-  c.{self::M::f}(1);
+  c.{self::C::f}(1);
 }
 static method g2(self::I<core::num*>* i) → void {
   i.{self::I::f}(1.5);

pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.strong.expect

@@ -27,7 +27,7 @@ class C = self::B with self::M implements self::I<core::int*> {
     return super.{self::B::f}(x);
 }
 static method g1(self::C* c) → void {
-  c.{self::B::f}(1);
+  c.{self::C::f}(1);
 }
 static method g2(self::I<core::num*>* i) → void {
   i.{self::I::f}(1.5);

pkg/front_end/testcases/runtime_checks/covariant_generic_parameter_in_interface_super_mixin.dart.strong.transformed.expect

@@ -27,7 +27,7 @@ class C extends self::B implements self::I<core::int*>, self::M /*isEliminatedMi
     return super.{self::B::f}(x);
 }
 static method g1(self::C* c) → void {
-  c.{self::B::f}(1);
+  c.{self::C::f}(1);
 }
 static method g2(self::I<core::num*>* i) → void {
   i.{self::I::f}(1.5);

pkg/kernel/lib/transformations/mixin_full_resolution.dart

@@ -192,14 +192,15 @@ class MixinFullResolution {
         referenceFrom =
             indexedClass?.lookupProcedureNotSetter(procedure.name.name);
       }
-      Procedure clone = cloner.cloneProcedure(procedure, referenceFrom);
+
       // Linear search for a forwarding stub with the same name.
+      int originalIndex;
       for (int i = 0; i < originalLength; ++i) {
         var originalProcedure = class_.procedures[i];
-        if (originalProcedure.name == clone.name &&
-            originalProcedure.kind == clone.kind) {
+        if (originalProcedure.name == procedure.name &&
+            originalProcedure.kind == procedure.kind) {
           FunctionNode src = originalProcedure.function;
-          FunctionNode dst = clone.function;
+          FunctionNode dst = procedure.function;
 
           if (src.positionalParameters.length !=
                   dst.positionalParameters.length ||
@@ -208,27 +209,35 @@ class MixinFullResolution {
             // and don't add several procedures with the same name to the class.
             continue outer;
           }
-
-          assert(src.typeParameters.length == dst.typeParameters.length);
-          for (int j = 0; j < src.typeParameters.length; ++j) {
-            dst.typeParameters[j].flags = src.typeParameters[j].flags;
-          }
-          for (int j = 0; j < src.positionalParameters.length; ++j) {
-            dst.positionalParameters[j].flags =
-                src.positionalParameters[j].flags;
-          }
-          // TODO(kernel team): The named parameters are not sorted,
-          // this might not be correct.
-          for (int j = 0; j < src.namedParameters.length; ++j) {
-            dst.namedParameters[j].flags = src.namedParameters[j].flags;
-          }
-
-          originalProcedure.canonicalName?.unbind();
-          class_.procedures[i] = clone;
-          continue outer;
+          originalIndex = i;
+          break;
         }
       }
-      class_.addMember(clone);
+      if (originalIndex != null) {
+        referenceFrom ??= class_.procedures[originalIndex];
+      }
+      Procedure clone = cloner.cloneProcedure(procedure, referenceFrom);
+      if (originalIndex != null) {
+        Procedure originalProcedure = class_.procedures[originalIndex];
+        FunctionNode src = originalProcedure.function;
+        FunctionNode dst = clone.function;
+        assert(src.typeParameters.length == dst.typeParameters.length);
+        for (int j = 0; j < src.typeParameters.length; ++j) {
+          dst.typeParameters[j].flags = src.typeParameters[j].flags;
+        }
+        for (int j = 0; j < src.positionalParameters.length; ++j) {
+          dst.positionalParameters[j].flags = src.positionalParameters[j].flags;
+        }
+        // TODO(kernel team): The named parameters are not sorted,
+        // this might not be correct.
+        for (int j = 0; j < src.namedParameters.length; ++j) {
+          dst.namedParameters[j].flags = src.namedParameters[j].flags;
+        }
+
+        class_.procedures[originalIndex] = clone;
+      } else {
+        class_.addMember(clone);
+      }
     }
     assert(class_.constructors.isNotEmpty);