Take @TargetNAME into account when resolving extension methods of value classes

Before target name we only matched on signatures. This was OK, since multiple extension
methods of the same class must be different, otherwise we will get a "have the same erasure"
error later at erasurePhase. But with @TargetNAME that's now a legal situation that
needs to be resolve correctly. We do this by propagating the target name to the extension
method and verifiying that the target names of the original and extension methods match.

Fixes #16464

Author: odersky

compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala

@@ -188,9 +188,17 @@ object ExtensionMethods {
       val companion = imeth.owner.companionModule
       val companionInfo = companion.info
       val candidates = companionInfo.decl(extensionName(imeth)).alternatives
-      val matching =
-        // See the documentation of `memberSignature` to understand why `.stripPoly.ensureMethodic` is needed here.
-        candidates filter (c => FullParameterization.memberSignature(c.info) == imeth.info.stripPoly.ensureMethodic.signature)
+      def matches(candidate: SingleDenotation) =
+        FullParameterization.memberSignature(candidate.info) == imeth.info.stripPoly.ensureMethodic.signature
+          // See the documentation of `memberSignature` to understand why `.stripPoly.ensureMethodic` is needed here.
+        && (if imeth.targetName == imeth.name then
+              // imeth does not have a @targetName annotation, candidate should not have one either
+              candidate.symbol.targetName == candidate.symbol.name
+            else
+              // imeth has a @targetName annotation, candidate's target name must match
+              imeth.targetName == candidate.symbol.targetName
+           )
+      val matching = candidates.filter(matches)
       assert(matching.nonEmpty,
        i"""no extension method found for:
           |
@@ -203,6 +211,9 @@ object ExtensionMethods {
           | Candidates (signatures normalized):
           |
           | ${candidates.map(c => s"${c.name}:${c.info.signature}:${FullParameterization.memberSignature(c.info)}").mkString("\n")}""")
+      if matching.tail.nonEmpty then
+        // this case will report a "have the same erasure" error later at erasure pahse
+        report.log(i"mutiple extension methods match $imeth: ${candidates.map(c => i"${c.name}:${c.info}")}")
       matching.head.symbol.asTerm
     }
 }

tests/neg/i16464.scala

@@ -0,0 +1,6 @@
+
+implicit final class SomeOps(e: Int) extends AnyVal:
+  def -(other: Seq[Int]) = List(1)
+  def -(other: Seq[Long]) = List(2) // error: double definition
+
+def main(): Unit = 1 - Seq.empty[Int]

tests/pos/i16464.scala

@@ -0,0 +1,26 @@
+import scala.annotation.targetName
+
+object test1:
+  implicit final class SomeOps(e: Int) extends AnyVal:
+    @targetName("a")
+    def -(other: Seq[Int]) = List(1)
+    @targetName("b")
+    def -(other: Seq[Long]) = List(2)
+
+  def main(): Unit = 1 - Seq.empty[Int]
+
+object test2:
+  implicit final class SomeOps(e: Int) extends AnyVal:
+    @targetName("a")
+    def -(other: Seq[Int]) = List(1)
+    def -(other: Seq[Long]) = List(2)
+
+  def main(): Unit = 1 - Seq.empty[Int]
+
+object test3:
+  implicit final class SomeOps(e: Int) extends AnyVal:
+    def -(other: Seq[Int]) = List(1)
+    @targetName("b")
+    def -(other: Seq[Long]) = List(2)
+
+  def main(): Unit = 1 - Seq.empty[Int]

tests/run/i16464.scala

@@ -0,0 +1,10 @@
+import scala.annotation.targetName
+
+implicit final class SomeOps(e: Int) extends AnyVal:
+  @targetName("a")
+  def -(other: Seq[Int]) = List(1)
+  @targetName("b")
+  def -(other: Seq[Long]) = List(2)
+
+@main
+def Test(): Unit = 1 - Seq.empty[Int]